Array Based Link List

#include <iostream.h>
#include <conio.h>

static int bytes = 0;

struct Node {
Node() { bytes += sizeof(char); }
~Node() { bytes -= sizeof(char); }
char item;
Node* next;
};

int main() {
clrscr();
Node* head = new Node;
Node* curr = new Node;
head = curr;                  // save position of first element, so we know where our list starts

const int total = 5;
char c = ‘A’;
int i;
for (i = 0; i < total; ++i, ++c) {
curr->item = c;             // assign value
curr->next = new Node;      // create new element
curr = curr->next;          // move to that new element
}
curr->next = NULL;            // place a ‘stop’ sign

curr = head;                  // move to first element
for (i = 0; i < total; ++i) {
cout << curr->item << ” “;  // display element
curr = curr->next;          // move to next one
}
/*
for (i = total; i > 0; i–) {
curr = head;                // get position of first element
for (int j = 0; j < i; j++) {
curr = curr->next;        // move to the last element
}
delete curr;                // delete last element
}
*/
delete head;
delete curr;

cout << endl << “Bytes: ” << bytes;
return 0;
}

Queue Based on Link List

#include <iostream.h>
#include <stdio.h>
#include <conio.h>

struct node
{
int data;
node *next;
}*front = NULL, *rear = NULL, *p = NULL, *np = NULL;

void push(int x)
{
np = new node;
np->data = x;
np->next = NULL;
if(front == NULL)
{
front = rear = np;
rear->next = NULL;
}
else
{
rear->next = np;
rear = np;
rear->next = NULL;
}
}

int remove()
{
int x;
if (front == NULL)
{
cout<<“empty queue\n”;
}
else
{
p = front;
x = p->data;
front = front->next;
delete(p);
return(x);
}
return(NULL);
}

void main()
{
int n, c = 0, x;
cout<<“Enter the number of values to be pushed into queue\n”;
cin>>n;
while (c < n)
{
cout<<“Enter the value to be entered into queue\n”;
cin>>x;
push(x);
c++;
}
cout<<“\n\nRemoved Values\n\n”;
while(1)
{
if (front != NULL)
cout<<remove()<<endl;
else
break;
}
getch();
}

Stack Based on Link List

#include <iostream.h>

struct node
{
int data;
node *link;
};

class lstack
{
private:
node* top;

public:
lstack()
{
top=NULL;
}

void push(int n)
{
node *tmp;
tmp=new node;
if(tmp==NULL)
cout<<“\nSTACK FULL”;

tmp->data=n;
tmp->link=top;
top=tmp;
}

int pop()
{
if(top==NULL)
{
cout<<“\nSTACK EMPTY”;
cout<<endl;
return NULL;
}
node *tmp;
int n;
tmp=top;
n=tmp->data;
top=top->link;
delete tmp;
return n;
}

~lstack()
{
if(top==NULL)
return;

node *tmp;
while (top!=NULL)
{
tmp=top;
top=top->link;
delete tmp;
}
}
};

int main()
{
lstack s;
s.push(11);
s.push(22);
s.push(99);
s.push(77);
cout<<“Item Popped = “<<s.pop()<<endl;
cout<<“Item Popped = “<<s.pop()<<endl;
cout<<“Item Popped = “<<s.pop()<<endl;
cout<<“Item Popped = “<<s.pop()<<endl;
cout<<“Item Popped = “<<s.pop()<<endl;
return 0;
}

Singly Link List (Lihat Doubly link list)

/*
* C++ Program to Implement Singly Linked List
*/
#include<iostream.h>
#include<stdio.h>
#include<stdlib.h>

/*
* Node Declaration
*/

struct node
{
int info;
struct node *next;
}*start;

/*
* Class Declaration
*/
class single_llist
{
public:
node* create_node(int);
void insert_begin();
void insert_pos();
void insert_last();
void delete_pos();
void sort();
void search();
void update();
void reverse();
void display();
single_llist()
{
start = NULL;
}
};

enum bool {false, true};
/*
* Main :contains menu
*/
main()
{
int choice, nodes, element, position, i;
single_llist sl;
start = NULL;
while (true)
{
cout<<endl<<“———————————“<<endl;
cout<<endl<<“Operations on singly linked list”<<endl;
cout<<endl<<“———————————“<<endl;
cout<<“1.Insert Node at beginning”<<endl;
cout<<“2.Insert node at last”<<endl;
cout<<“3.Insert node at position”<<endl;
cout<<“4.Sort Link List”<<endl;
cout<<“5.Delete a Particular Node”<<endl;
cout<<“6.Update Node Value”<<endl;
cout<<“7.Search Element”<<endl;
cout<<“8.Display Linked List”<<endl;
cout<<“9.Reverse Linked List “<<endl;
cout<<“10.Exit “<<endl;
cout<<“Enter your choice : “;
cin>>choice;
switch(choice)
{
case 1:
cout<<“Inserting Node at Beginning: “<<endl;
sl.insert_begin();
cout<<endl;
break;
case 2:
cout<<“Inserting Node at Last: “<<endl;
sl.insert_last();
cout<<endl;
break;
case 3:
cout<<“Inserting Node at a given position:”<<endl;
sl.insert_pos();
cout<<endl;
break;
case 4:
cout<<“Sort Link List: “<<endl;
sl.sort();
cout<<endl;
break;
case 5:
cout<<“Delete a particular node: “<<endl;
sl.delete_pos();
break;
case 6:
cout<<“Update Node Value:”<<endl;
sl.update();
cout<<endl;
break;
case 7:
cout<<“Search element in Link List: “<<endl;
sl.search();
cout<<endl;
break;
case 8:
cout<<“Display elements of link list”<<endl;
sl.display();
cout<<endl;
break;
case 9:
cout<<“Reverse elements of Link List”<<endl;
sl.reverse();
cout<<endl;
break;
case 10:
cout<<“Exiting…”<<endl;
exit(1);
break;
default:
cout<<“Wrong choice”<<endl;
}
}
}

/*
* Creating Node
*/
node *single_llist::create_node(int value)

{
struct node *temp, *s;
temp = new(struct node);
if (temp == NULL)
{
cout<<“Memory not allocated “<<endl;
return 0;
}
else
{
temp->info = value;
temp->next = NULL;
return temp;
}
}

/*
* Inserting element in beginning
*/

void single_llist::insert_begin()
{
int value;
cout<<“Enter the value to be inserted: “;
cin>>value;
struct node *temp, *p;
temp = create_node(value);
if (start == NULL)
{
start = temp;
start->next = NULL;
}
else
{
p = start;
start = temp;
start->next = p;
}
cout<<“Element Inserted at beginning”<<endl;
}

/*
* Inserting Node at last
*/
void single_llist::insert_last()
{
int value;
cout<<“Enter the value to be inserted: “;
cin>>value;
struct node *temp, *s;
temp = create_node(value);
s = start;
while (s->next != NULL)
{
s = s->next;
}
temp->next = NULL;
s->next = temp;
cout<<“Element Inserted at last”<<endl;
}

/*
* Insertion of node at a given position
*/

void single_llist::insert_pos()
{
int value, pos, counter = 0;
cout<<“Enter the value to be inserted: “;
cin>>value;
struct node *temp, *s, *ptr;
temp = create_node(value);
cout<<“Enter the postion at which node to be inserted: “;
cin>>pos;
int i;
s = start;
while (s != NULL)
{
s = s->next;
counter++;
}
if (pos == 1)
{
if (start == NULL)
{
start = temp;
start->next = NULL;
}
else
{
ptr = start;
start = temp;
start->next = ptr;
}
}
else if (pos > 1  && pos <= counter)
{
s = start;
for (i = 1; i < pos; i++)
{
ptr = s;
s = s->next;
}
ptr->next = temp;
temp->next = s;
}
else
{
cout<<“Positon out of range”<<endl;
}
}

/*
* Sorting Link List
*/
void single_llist::sort()
{
struct node *ptr, *s;
int value;
if (start == NULL)
{
cout<<“The List is empty”<<endl;
return;
}
ptr = start;
while (ptr != NULL)
{
for (s = ptr->next;s !=NULL;s = s->next)
{
if (ptr->info > s->info)
{
value = ptr->info;
ptr->info = s->info;
s->info = value;
}
}
ptr = ptr->next;
}
}

/*
* Delete element at a given position
*/

void single_llist::delete_pos()
{
int pos, i, counter = 0;
if (start == NULL)
{
cout<<“List is empty”<<endl;
return;
}
cout<<“Enter the position of value to be deleted: “;
cin>>pos;
struct node *s, *ptr;
s = start;
if (pos == 1)
{
start = s->next;
}
else
{
while (s != NULL)
{
s = s->next;
counter++;
}
if (pos > 0 && pos <= counter)
{
s = start;
for (i = 1;i < pos;i++)
{
ptr = s;
s = s->next;
}
ptr->next = s->next;
}
else
{
cout<<“Position out of range”<<endl;
}
free(s);
cout<<“Element Deleted”<<endl;
}
}

/*
* Update a given Node
*/
void single_llist::update()
{
int value, pos, i;
if (start == NULL)
{
cout<<“List is empty”<<endl;
return;
}
cout<<“Enter the node postion to be updated: “;
cin>>pos;
cout<<“Enter the new value: “;
cin>>value;
struct node *s, *ptr;
s = start;
if (pos == 1)
{
start->info = value;
}
else
{
for (i = 0;i < pos – 1;i++)
{
if (s == NULL)
{
cout<<“There are less than “<<pos<<” elements”;
return;
}
s = s->next;
}
s->info = value;
}
cout<<“Node Updated”<<endl;
}

/*
* Searching an element
*/
void single_llist::search()
{
int value, pos = 0;
bool flag = false;
if (start == NULL)
{
cout<<“List is empty”<<endl;
return;
}
cout<<“Enter the value to be searched: “;
cin>>value;
struct node *s;
s = start;
while (s != NULL)
{
pos++;
if (s->info == value)
{
flag = true;
cout<<“Element “<<value<<” is found at position “<<pos<<endl;
}
s = s->next;
}
if (!flag)
cout<<“Element “<<value<<” not found in the list”<<endl;
}

/*
* Reverse Link List
*/

void single_llist::reverse()
{
struct node *ptr1, *ptr2, *ptr3;
if (start == NULL)
{
cout<<“List is empty”<<endl;
return;
}
if (start->next == NULL)
{
return;
}
ptr1 = start;
ptr2 = ptr1->next;
ptr3 = ptr2->next;
ptr1->next = NULL;
ptr2->next = ptr1;
while (ptr3 != NULL)
{
ptr1 = ptr2;
ptr2 = ptr3;
ptr3 = ptr3->next;
ptr2->next = ptr1;
}
start = ptr2;
}

/*
* Display Elements of a link list
*/
void single_llist::display()
{
struct node *temp;
if (start == NULL)
{
cout<<“The List is Empty”<<endl;
return;
}
temp = start;
cout<<“Elements of list are: “<<endl;
while (temp != NULL)
{
cout<<temp->info<<“->”;
temp = temp->next;
}
cout<<“NULL”<<endl;
}

Doubly link list (lihat circular link list)

/*
* C++ Program to Implement Doubly Linked List
*/

#include<iostream.h>
#include<stdio.h>
#include<stdlib.h>
/*
* Node Declaration
*/
struct node
{
int info;
struct node *next;
struct node *prev;
}*start;

/*
Class Declaration
*/
class double_llist
{
public:
void create_list(int value);
void add_begin(int value);
void add_after(int value, int position);
void delete_element(int value);
void search_element(int value);
void display_dlist();
void count();
void reverse();
double_llist()
{
start = NULL;
}
};

/*
* Main: Contains Menu
*/
void main()
{
int choice, element, position;
double_llist dl;
while (1)
{
cout<<endl<<“—————————-“<<endl;
cout<<endl<<“Operations on Doubly linked list”<<endl;
cout<<endl<<“—————————-“<<endl;
cout<<“1.Create Node”<<endl;
cout<<“2.Add at begining”<<endl;
cout<<“3.Add after position”<<endl;
cout<<“4.Delete”<<endl;
cout<<“5.Display”<<endl;
cout<<“6.Count”<<endl;
cout<<“7.Reverse”<<endl;
cout<<“8.Quit”<<endl;
cout<<“Enter your choice : “;
cin>>choice;
switch ( choice )
{
case 1:
cout<<“Enter the element: “;
cin>>element;
dl.create_list(element);
cout<<endl;
break;
case 2:
cout<<“Enter the element: “;
cin>>element;
dl.add_begin(element);
cout<<endl;
break;
case 3:
cout<<“Enter the element: “;
cin>>element;
cout<<“Insert Element after postion: “;
cin>>position;
dl.add_after(element, position);
cout<<endl;
break;
case 4:
if (start == NULL)
{
cout<<“List empty,nothing to delete”<<endl;
break;
}
cout<<“Enter the element for deletion: “;
cin>>element;
dl.delete_element(element);
cout<<endl;
break;
case 5:
dl.display_dlist();
cout<<endl;
break;
case 6:
dl.count();
break;
case 7:
if (start == NULL)
{
cout<<“List empty,nothing to reverse”<<endl;
break;
}
dl.reverse();
cout<<endl;
break;
case 8:
exit(1);
default:
cout<<“Wrong choice”<<endl;
}
}
}

/*
* Create Double Link List
*/

void double_llist::create_list(int value)
{
struct node *s, *temp;
temp = new(struct node);
temp->info = value;
temp->next = NULL;
if (start == NULL)
{
temp->prev = NULL;
start = temp;
}
else
{
s = start;
while (s->next != NULL)
s = s->next;
s->next = temp;
temp->prev = s;
}
}

/*
* Insertion at the beginning
*/

void double_llist::add_begin(int value)
{
if (start == NULL)
{
cout<<“First Create the list.”<<endl;
return;
}
struct node *temp;
temp = new(struct node);
temp->prev = NULL;
temp->info = value;
temp->next = start;
start->prev = temp;
start = temp;
cout<<“Element Inserted”<<endl;
}

/*
* Insertion of element at a particular position
*/

void double_llist::add_after(int value, int pos)
{
if (start == NULL)
{
cout<<“First Create the list.”<<endl;
return;
}
struct node *tmp, *q;
int i;
q = start;
for (i = 0;i < pos – 1;i++)
{
q = q->next;
if (q == NULL)
{
cout<<“There are less than “;
cout<<pos<<” elements.”<<endl;
return;
}
}
tmp = new(struct node);
tmp->info = value;
if (q->next == NULL)
{
q->next = tmp;
tmp->next = NULL;
tmp->prev = q;
}
else
{
tmp->next = q->next;
tmp->next->prev = tmp;
q->next = tmp;
tmp->prev = q;
}
cout<<“Element Inserted”<<endl;
}

/*
* Deletion of element from the list
*/

void double_llist::delete_element(int value)
{
struct node *tmp, *q;
/*first element deletion*/
if (start->info == value)
{
tmp = start;
start = start->next;
start->prev = NULL;
cout<<“Element Deleted”<<endl;
free(tmp);
return;
}
q = start;
while (q->next->next != NULL)
{
/*Element deleted in between*/
if (q->next->info == value)
{
tmp = q->next;
q->next = tmp->next;
tmp->next->prev = q;
cout<<“Element Deleted”<<endl;
free(tmp);
return;
}
q = q->next;
}
/*last element deleted*/
if (q->next->info == value)
{
tmp = q->next;
free(tmp);
q->next = NULL;
cout<<“Element Deleted”<<endl;
return;
}
cout<<“Element “<<value<<” not found”<<endl;
}

/*
* Display elements of Doubly Link List
*/
void double_llist::display_dlist()
{
struct node *q;
if (start == NULL)
{
cout<<“List empty,nothing to display”<<endl;
return;
}
q = start;
cout<<“The Doubly Link List is :”<<endl;
while (q != NULL)
{
cout<<q->info<<” <-> “;
q = q->next;
}
cout<<“NULL”<<endl;
}

/*
* Number of elements in Doubly Link List
*/

void double_llist::count()
{
struct node *q = start;
int cnt = 0;
while (q != NULL)
{
q = q->next;
cnt++;
}
cout<<“Number of elements are: “<<cnt<<endl;
}

/*
* Reverse Doubly Link List
*/

void double_llist::reverse()
{
struct node *p1, *p2;
p1 = start;
p2 = p1->next;
p1->next = NULL;
p1->prev = p2;
while (p2 != NULL)
{
p2->prev = p2->next;
p2->next = p1;
p1 = p2;
p2 = p2->prev;
}
start = p1;
cout<<“List Reversed”<<endl;
}

Circular link list (coba ini)

/*
* C++ Program to Implement Circular Linked List
*/
#include<iostream.h>
#include<stdio.h>
#include<stdlib.h>

/*
* Node Declaration
*/

struct node
{
int info;
struct node *next;
}*last;

/*
* Class Declaration
*/

class circular_llist
{
public:
void create_node(int value);
void add_begin(int value);
void add_after(int value, int position);
void delete_element(int value);
void search_element(int value);
void display_list();
void update();
void sort();
circular_llist()
{
last = NULL;
}
};

/*
* Main :contains menu
*/

void main()
{
int choice, element, position;
circular_llist cl;
while (1)
{
cout<<endl<<“—————————“<<endl;
cout<<endl<<“Circular singly linked list”<<endl;
cout<<endl<<“—————————“<<endl;
cout<<“1.Create Node”<<endl;
cout<<“2.Add at beginning”<<endl;
cout<<“3.Add after”<<endl;
cout<<“4.Delete”<<endl;
cout<<“5.Search”<<endl;
cout<<“6.Display”<<endl;
cout<<“7.Update”<<endl;
cout<<“8.Sort”<<endl;
cout<<“9.Quit”<<endl;
cout<<“Enter your choice : “;
cin>>choice;
switch(choice)
{
case 1:
cout<<“Enter the element: “;
cin>>element;
cl.create_node(element);
cout<<endl;
break;
case 2:
cout<<“Enter the element: “;
cin>>element;
cl.add_begin(element);
cout<<endl;
break;
case 3:
cout<<“Enter the element: “;
cin>>element;
cout<<“Insert element after position: “;
cin>>position;
cl.add_after(element, position);
cout<<endl;
break;
case 4:
if (last == NULL)
{
cout<<“List is empty, nothing to delete”<<endl;
break;
}
cout<<“Enter the element for deletion: “;
cin>>element;
cl.delete_element(element);
cout<<endl;
break;
case 5:
if (last == NULL)
{
cout<<“List Empty!! Can’t search”<<endl;
break;
}
cout<<“Enter the element to be searched: “;
cin>>element;
cl.search_element(element);
cout<<endl;
break;
case 6:
cl.display_list();
break;
case 7:
cl.update();
break;
case 8:
cl.sort();
break;
case 9:
exit(1);
break;
default:
cout<<“Wrong choice”<<endl;
}
}
}

/*
* Create Circular Link List
*/

void circular_llist::create_node(int value)
{
struct node *temp;
temp = new(struct node);
temp->info = value;
if (last == NULL)
{
last = temp;
temp->next = last;
}
else
{
temp->next = last->next;
last->next = temp;
last = temp;
}
}

/*
* Insertion of element at beginning
*/

void circular_llist::add_begin(int value)
{
if (last == NULL)
{
cout<<“First Create the list.”<<endl;
return;
}
struct node *temp;
temp = new(struct node);
temp->info = value;
temp->next = last->next;
last->next = temp;
}

/*
* Insertion of element at a particular place
*/

void circular_llist::add_after(int value, int pos)
{
if (last == NULL)
{
cout<<“First Create the list.”<<endl;
return;
}
struct node *temp, *s;
s = last->next;
for (int i = 0;i < pos-1;i++)
{
s = s->next;
if (s == last->next)
{
cout<<“There are less than “;
cout<<pos<<” in the list”<<endl;
return;
}
}
temp = new(struct node);
temp->next = s->next;
temp->info = value;
s->next = temp;
/*Element inserted at the end*/
if (s == last)
{
last=temp;
}
}

/*
* Deletion of element from the list
*/

void circular_llist::delete_element(int value)
{
struct node *temp, *s;
s = last->next;
/* If List has only one element*/
if (last->next == last && last->info == value)
{
temp = last;
last = NULL;
free(temp);
return;
}
if (s->info == value)  /*First Element Deletion*/
{
temp = s;
last->next = s->next;
free(temp);
return;
}
while (s->next != last)
{
/*Deletion of Element in between*/
if (s->next->info == value)
{
temp = s->next;
s->next = temp->next;
free(temp);
cout<<“Element “<<value;
cout<<” deleted from the list”<<endl;
return;
}
s = s->next;
}
/*Deletion of last element*/
if (s->next->info == value)
{
temp = s->next;
s->next = last->next;
free(temp);
last = s;
return;
}
cout<<“Element “<<value<<” not found in the list”<<endl;
}

/*
* Search element in the list
*/

void circular_llist::search_element(int value)
{
struct node *s;
int counter = 0;
s = last->next;
while (s != last)
{
counter++;
if (s->info == value)
{
cout<<“Element “<<value;
cout<<” found at position “<<counter<<endl;
return;
}
s = s->next;
}
if (s->info == value)
{
counter++;
cout<<“Element “<<value;
cout<<” found at position “<<counter<<endl;
return;
}
cout<<“Element “<<value<<” not found in the list”<<endl;
}

/*
* Display Circular Link List
*/

void circular_llist::display_list()
{
struct node *s;
if (last == NULL)
{
cout<<“List is empty, nothing to display”<<endl;
return;
}
s = last->next;
cout<<“Circular Link List: “<<endl;
while (s != last)
{
cout<<s->info<<“->”;
s = s->next;
}
cout<<s->info<<endl;
}

/*
* Update Circular Link List
*/

void circular_llist::update()
{
int value, pos, i;
if (last == NULL)
{
cout<<“List is empty, nothing to update”<<endl;
return;
}
cout<<“Enter the node position to be updated: “;
cin>>pos;
cout<<“Enter the new value: “;
cin>>value;
struct node *s;
s = last->next;
for (i = 0;i < pos – 1;i++)
{
if (s == last)
{
cout<<“There are less than “<<pos<<” elements.”;
cout<<endl;
return;
}
s = s->next;
}
s->info = value;
cout<<“Node Updated”<<endl;
}

/*
* Sort Circular Link List
*/

void circular_llist::sort()
{
struct node *s, *ptr;
int temp;
if (last == NULL)
{
cout<<“List is empty, nothing to sort”<<endl;
return;
}
s = last->next;
while (s != last)
{
ptr = s->next;
while (ptr != last->next)
{
if (ptr != last->next)
{
if (s->info > ptr->info)
{
temp = s->info;
s->info = ptr->info;
ptr->info = temp;
}
}
else
{
break;
}
ptr = ptr->next;
}
s = s->next;
}
}

doubly link list (coba ini)

#include <iostream.h>

struct Node
{
double value;
Node *N,*P;
Node(double y)
{
value = y;
N = P = NULL;
}
};

class doubleLinkedList
{
Node *front;
Node *back;
public:
doubleLinkedList()
{  front = NULL; back = NULL; }
~doubleLinkedList(){ destroyList();}
void appendNodeFront(double x);
void appendNodeBack(double x);
void dispNodesForward();
void dispNodesReverse();
void destroyList();
};

void doubleLinkedList::appendNodeFront(double x)
{
Node *n = new Node(x);
if( front == NULL)
{
front = n;
back = n;
}
else
{
front->P = n;
n->N = front;
front = n;
}
}
void doubleLinkedList::appendNodeBack(double x)
{
Node *n = new Node(x);
if( back == NULL)
{
front = n;
back = n;
}
else
{
back->N = n;
n->P = back;
back = n;
}

}

void doubleLinkedList::dispNodesForward()
{
Node *temp = front;
cout << “\n\nNodes in forward order:” << endl;
while(temp != NULL)
{
cout << temp->value << ”   ” ;
temp = temp->N;
}
}
void doubleLinkedList::dispNodesReverse()
{
Node *temp = back;
cout << “\n\nNodes in reverse order :” << endl;
while(temp != NULL)
{
cout << temp->value << ”   ” ;
temp = temp->P;
}
}
void doubleLinkedList::destroyList()
{
Node *T = back;
while(T != NULL)
{
Node *T2 = T;
T = T->P;
delete T2;
}
front = NULL;
back = NULL;
}
int main()
{
doubleLinkedList *list = new doubleLinkedList();
//append nodes to front of the list
for( int i = 1 ; i < 4 ; i++)
list->appendNodeFront(i*1.1);

list->dispNodesForward();
list->dispNodesReverse();

//append nodes to back of the list
for( int i = 1 ; i < 4 ; i++)
list->appendNodeBack(11.0 – (1.1 * i));
cout << endl << endl;
list->dispNodesForward();
list->dispNodesReverse();

cout << endl << endl;
delete list;
return 0;
}