LINKLIST #include <iostream>using namespace std;class Node {public: int info; Node* link;

Node(int a) { info=a; link=NULL; }};class LinkList {public: Node* Start; Node* Ptr; LinkList()
{ Start=NULL; Ptr=NULL; } ~LinkList() { Node* temp; while (Start != NULL)
{ temp = Start; Start = Start->link; delete temp; } } void createNode(int x) { if (Ptr
== NULL) { Ptr = Start = new Node(x); } else { Ptr->link = new Node(x); Ptr = Ptr-
>link; } }void UnsortedSearch(int item) { Ptr = Start; int LOC = NULL; while (Ptr !=
NULL) { if (item == Ptr->info) { cout << "Item found at location: " << LOC << endl; return;
} Ptr = Ptr->link; LOC++; } cout << "Item not found" << endl; } void sortedSearch(int
item) { Ptr = Start; int LOC = NULL; while (Ptr != NULL) { if (item > Ptr->info) { Ptr =
Ptr->link; LOC++;} else if(item==Ptr->info){ cout << "Item found at location: " <<
LOC << endl; return; } else { break; } }
cout << "Item not found" << endl; }void InsertFirst(int item) { Node* newNode = new
Node(item); newNode->link = Start; Start = newNode; } void Traverse() { Node* Ptr =
Start; while (Ptr != NULL) { cout << Ptr->info << " "; Ptr = Ptr->link; } cout << endl; }void
FINDA(int item, Node*& LOC) { if (Start == NULL) { LOC = NULL; return; } if (item
< Start->info) { LOC = NULL; return; } Node* SAVE = Start; Ptr = Start->link; while
(Ptr != NULL) { if (item < Ptr->info) { LOC = SAVE; return; } SAVE = Ptr; Ptr =
Ptr->link; } LOC = SAVE; }void InsertSort(int item) { Node* LOC; FINDA(item, LOC);
Node* newNode = new Node(item); if (LOC == NULL) { newNode->link = Start; Start =
newNode; } else { newNode->link = LOC->link; LOC->link = newNode; } }void
InsertBetween(int LOC, int item) { Node *t = Start; while (t != NULL && t->info != LOC)
{ t = t->link; } if (t == NULL) { cout << "No Node find at your gien location" << endl; }
else { Node *newNode = new Node(item); if (newNode == NULL) { cout << "Overflow!
Unable to allocate memory for the new node." << endl; return; } newNode->link = t-
>link; t->link = newNode; } }void FINDB(int item, Node *&LOC, Node *&LOCP){ LOC
= NULL; LOCP = NULL; if (Start == NULL) { return; } if (Start->info == item) { LOC = Start;
LOCP = NULL; return; } Node *Save = Start; Ptr = Start->link; while (Ptr != NULL) { if (Ptr-
>info == item) { LOC = Ptr; LOCP = Save; return; } Save = Ptr; Ptr = Ptr->link; } LOC
= NULL;}void DeleteNode(int item){ Node *LOC = NULL; Node *LOCP = NULL; FINDB(item,
LOC, LOCP); if (LOC == NULL) { cout << "Item not found in the list" << endl; return; } if (LOCP
== NULL) { Start = Start->link; } else { LOCP->link = LOC->link; } delete LOC; } int main(){
LinkedList obj; obj.createNode(11); obj.createNode(14); obj.createNode(13);

DoubleLINKLIST#include <iostream>using namespace std;class Node{public: int info; Node

*FORW; Node *PREV; Node(int x) { info = x; FORW = PREV = NULL; }};class
DoubleLinkedList{public: Node *Start; Node *Ptr; Node *AVAIL; DoubleLinkedList() { Start =
Ptr = NULL; } void createNode(int item) { Node *newNode = new Node(item); if (Start ==
NULL) { Start = Ptr = newNode; } else { Ptr->FORW = newNode; newNode->PREV =
Ptr; Ptr = newNode; } } void traverse() { Node *temp = Start; while (temp != NULL) {
cout << temp->info << " "; temp = temp->FORW; } cout << endl; } Node *SearchNode(int
item, Node *&LOC) { Node *temp = Start; LOC = NULL; while (temp != NULL && temp->info
!= item) { temp = temp->FORW; } if (temp == NULL) { LOC = NULL; } else { LOC
= temp; } return LOC; } void DeleteNode(int item) { Node *LOC; SearchNode(item, LOC);
if (LOC == NULL) { cout << "Node with value " << item << " not found." << endl; return; }
if (LOC == Start) { Start = Start->FORW; if (Start != NULL) { Start->PREV = NULL; }
delete LOC; } else if (LOC->FORW == NULL) { LOC->FORW->PREV = NULL; delete LOC;
} else { LOC->PREV->FORW = LOC->FORW; LOC->FORW->PREV = LOC->PREV; delete
LOC; } } void InsertNodeAtStart(int item) { Node *newNode = new Node(item); if (Start
== NULL) { Start = Ptr = newNode; } else { newNode->FORW = Start; Start->PREV
= newNode; Start = newNode; } cout << "Node " << item << " inserted at the start." << endl;
} void InsertNodeAtEnd(int item) { Node *newNode = new Node(item); if (Start == NULL)
{ Start = Ptr = newNode; } else { Ptr->FORW = newNode; newNode->PREV = Ptr;
Ptr = newNode; } cout << "Node " << item << " inserted at the end." << endl; } void
InsertNodeAfter(int afterValue, int newValue){ Node* LOC = NULL; Node* temp =
SearchNode(afterValue, LOC); if (temp == NULL) { cout << "Node with value " << afterValue
<< " not found." << endl; return; } Node* newNode = new Node(newValue); newNode->FORW
= temp->FORW; newNode->PREV = temp; if (temp->FORW != NULL) { temp->FORW-
>PREV = newNode; } else { Ptr = newNode; } temp->FORW = newNode; cout << "Node " <<
newValue << " inserted after " << afterValue << "." << endl;}}; int main(){ DoubleLinkedList obj;
obj.createNode(11);obj.createNode(14);obj.createNode(13);obj.InsertNodeAtStart(4);obj.Insert
NodeAfter(14,15);obj.InsertNodeAtEnd(5); obj.traverse(); obj.DeleteNode(14); obj.traverse();}

TREE #include <iostream> using namespace std;class Tree {public: char info; Tree *left; Tree
*right; Tree(char in) { left = right = NULL; info =in; }}; void inorder(Tree *node) { if (node) {
inorder(node->left); cout << node->info << " "; inorder(node->right); }} void preorder(Tree
*node) { if (node) { cout << node->info << " "; preorder(node->left); preorder(node->right);
}} void postorder(Tree *node) { if (node) { postorder(node->left); postorder(node->right);
cout << node->info << " "; }} int main(){ Tree*Root; Root = new Tree('A'); Root-
>left = new Tree('B'); Root->left->left =new Tree('D'); Root->left->right = new Tree('E');
Root->left->right->left = new Tree('F'); Root->right =new Tree('C'); Root->right-
>left =new Tree('G'); Root->right->right = new Tree('H'); Root->right->right->left = new
Tree('J'); Root->right->right->left->left = new Tree('L'); Root->right->right->right =
new Tree ('K'); cout << "Inorder Traversal: "; inorder(Root); cout << endl; cout <<
"postorder Traversal: "; postorder(Root); cout << endl; cout << "preorder Traversal: ";
preorder(Root); cout << endl;}

#include <iostream>using namespace std; class Tree {public: int info; Tree *left; Tree *right;
Tree(int in) { left = right = NULL; info = in; }}; Tree* insert(Tree *root, int data) { if (!root)
return new Tree(data); if (data < root->info) { root->left = insert(root->left, data); } else if (data
> root->info) { root->right = insert(root->right, data); } return root;} void inorder(Tree *root) {
if (root) { inorder(root->left); cout << root->info << " "; inorder(root->right); }} int main() {
Tree *root = NULL; root = insert(root, 50); insert(root, 30); insert(root, 70); insert(root, 20);
insert(root, 40); insert(root, 60); insert(root, 80); cout << "Inorder Traversal (Sorted Order): ";
inorder(root); cout << endl; return 0;}
CircularLINKLIST#include <iostream>using namespace std;class Node{public: int info; Node
*Link; Node(int x) { info = x; Link = NULL; }};class CircularLinkedList{public: Node *Start;
CircularLinkedList() { Start = NULL; } void createNode(int x) { Node *newNode = new Node(x);
if (Start == NULL) { Start = newNode; newNode->Link = Start; } else { Node *temp
= Start; while (temp->Link != Start) { temp = temp->Link; } temp->Link = newNode;
newNode->Link = Start; } } void traverse() { if (Start == NULL) { cout << "List is empty."
<< endl; return; } Node *temp = Start; do { cout << temp->info << " "; temp = temp-
>Link; } while (temp != Start); cout << endl; } void SearchList(int item) { if (Start == NULL)
{ cout << "List is empty." << endl; return; } Node *temp = Start; while (temp->info !=
item && temp->Link != Start) { temp = temp->Link; } if (temp->info == item) { cout <<
"Item " << item << " found at node with address: " << temp << endl; } else { cout << "Item
" << item << " not found in the list." << endl; } } void FindBehind(int item, Node *&LOC, Node
*&LOCP) { if (Start == NULL) { LOC = NULL; LOCP = NULL; cout << "List is empty." <<
endl; return; } Node *Save = Start; Node *temp = Start->Link; LOC = NULL; LOCP =
NULL; while (temp->info != item && temp != Start) { Save = temp; temp = temp->Link;
} if (temp->info == item) { LOC = temp; LOCP = Save; } else { LOC = NULL; LOCP
= Save; } if (LOC != NULL) { cout << "Item " << item << " found at LOC: " << LOC << ", LOCP
(previous): " << LOCP << endl; } else { cout << "Item " << item << " not found. Last node is
at LOCP: " << LOCP << endl; } } void DeleteNode(int item) { Node *LOC; Node *LOCP;
FindBehind(item, LOC, LOCP); if (LOC == NULL) { cout << "Item not found in the list. Deletion
not possible." << endl; return; } if (LOC == Start) { Node *last = Start; while (last-
>Link != Start) { last = last->Link; } last->Link = Start->Link; Start = Start->Link; }
else { LOCP->Link = LOC->Link; } delete LOC; cout << "Item " << item << " deleted from
the list." << endl; }}; int main(){ CircularLinkedList obj; obj.createNode(11);
obj.createNode(12); obj.createNode(13); obj.createNode(14); cout << "Original List: ";
obj.traverse();