8/3/2019 DSC unit5
1/23
SK UNIT-5
1
Unit 5
Linked ListsThe main drawback of sequential representation is that fixed amount of storage remains allocated even
when it is not used.
Linear Linked list
Each item in the list is called a node and contains two fields Information field - The information field holds the actual elements in the list
Next address field- The next address field contains the address of the next node in the list
The entire linked list is accessed from an external pointer called the List. It contains the address of the
first element in the list.
The next address field of the last node contains a special value known as null, which is not a validaddress. Null indicates the end of the list.
The list with no nodes on it is called the empty list or the null list. When the list is empty the external
pointer first will contain the value null.
Notations for use in algorithms (not in C programs)
Node(p) refers to the node pointed to by that node.
Info(p) refers to the information of that node.
Next(p)-refers to the next address portion of that node.
Inserting nodes and removing nodes from the list.
A list is a dynamic data structure. The number of nodes in the list can vary dynamically as the elements
are inserted and removed from the list
The first step to insert an element into the list is to get an empty node into which we can store the
element to be inserted.
Once an empty node is got we can fill the information part of it with integer and it can be connected to
the list.
Algorithm to add a node to the front of the list is shown below.
P=getnode
info(p)=item // (p->info=item)next(p)=first // (p->next=first)
first=p;
Algorithm to remove a node from the front of a list is shown below. The deleted node is available forreuse.
p=first;first=next(p); // first=p->next
8/3/2019 DSC unit5
2/23
SK UNIT-5
2
x=info(p); //x= p->infofreenode(p);
Getnode operation
The getnode operation removes a node from a pool of free nodes called as the available list and makes it
available for use. The get node operation will return the first node from the available list. When theavailable list is empty and the getnode operation is called then the overflow occurs.
Assuming that avail is an external pointer that has the address of the first node in the available list thegetnode operation is implemented as follows.
getnode(){
If (avail=null){
Printf(overflow);Return(null);
}
P=avail;avail=next(avail)
return p;
}
The getnode operation can be invoked as
p=getnode and p will have the address of the free node
Free node operation
a node that is no longer used is returned to the pool by the free node operation. The node is added to thefront of the available list. This node will be returned by the next get node operation
The function free is used to free a node
Freenode(p)
{Next(p)=avail
avail=p;
}
Available list: It is the finite pool of empty nodes existing initially. The available list is a linked list that
behaves like a stack. The getnode operation removes the first node from the list and the freenode
operation adds a node to the front of the list.
In C we can represent a node as follows
8/3/2019 DSC unit5
3/23
SK UNIT-5
3
Struct node{
int info;
struct node *next;}
Linked implementation of stacks.
The operation of adding an element to the front of a linked list is similar to that of pushing an elementinto the stack. A stack can be accessed only through the top element and a list can only be accessed
through a pointer to its first element. The process of removing the first element from linked list is similar
to popping from the stack.
#include
#include
struct node{
int info;
struct node *link;};
typedef struct node NODE;
NODE* insert_front(int item,NODE * first){
NODE *temp,*cur;
temp=(NODE *)malloc(sizeof(struct node));
if(temp==NULL)
{
printf("stack overflow\n");return first;
}temp->info=item;
temp->link=first;
count++;
first=temp;return(first);
}
NODE* del_front(NODE *first){
NODE *temp;
if(first==NULL)
{
printf("Stack underflow\n");return first;
}
8/3/2019 DSC unit5
4/23
SK UNIT-5
4
temp=first;printf("the deleted item is %d\n",temp->info);
first=first->link;
count--;return(first);
}
void display(NODE *first)
{
NODE *temp;if(first==NULL)
{
printf("Stack empty\n");return;
}printf("Contents of stack are\n");
temp=first;while(temp!=NULL)
{
printf("%d\t",temp->info);temp=temp->link;
}
}
void main()
{int item,ch;
NODE *first,*temp;
first=NULL;
clrscr();for(;;)
{
printf("\nEnter the choice\n1:push\n2:pop\n3:display\n4:exit\n");scanf("%d",&ch);
switch(ch)
{
case 1:printf("Enter the item\n");scanf("%d",&item);
first=insert_front(item,first);
break;case 2:first=del_front(first);
break;
case 3:display(first);break;
default:exit(0);
8/3/2019 DSC unit5
5/23
SK UNIT-5
5
}}
}
Linked Implementation of queues
To implement a queue using a linked list we use two pointers the front and the rear. The front pointer
will have the address of the first node and the rear pointer will have the address of the last node. A newnode is always attached to the rear of the list and the node at the front will be deleted first.
#include#include
struct node
{
int info;
struct node *link;};
typedef struct node *NODE;
NODE insert_rear(int item,NODE rear)
{
NODE temp;temp=(NODE)malloc(sizeof(struct node));
if(temp==NULL)
{printf("queue overflow\n");
return(first)
}
temp=getnode();temp->info=item;
temp->link=NULL;
count++;if (rear==NULL)
return temp;
else{
rear->link=temp;
rear=temp;return rear;}
}
NODE del_front(NODE front){
NODE cur;
if(front==NULL)
8/3/2019 DSC unit5
6/23
SK UNIT-5
6
{printf("Queue underflow\n");
return front;
}cur=front;
printf("item deleted=%d\n",cur->info);
count--;
front=front->link;free(cur);
return front;
}
void display(NODE front){
NODE temp;
if(front==NULL){
printf("Queue is empty\n");return;
}printf("Contents of queue are\n");
temp=front;
while(temp!=NULL){
printf("%d\t",temp->info);
temp=temp->link;}
}
void main()
{
int item,ch;
NODE front,rear;front=NULL;
rear=NULL;
clrscr();for(;;)
{
printf("\nEnter the choice\n1:insert rear\n2:delete front\n3:display\n4:exit\n");
scanf("%d",&ch);switch(ch)
{
case 1:printf("Enter the item\n");scanf("%d",&item);
rear=insert_rear(item,rear);
if(count==1)front=rear;
break;
8/3/2019 DSC unit5
7/23
SK UNIT-5
7
case 2:front=del_front(front);if (count==0)
rear=NULL;
break;case 3:display(front);
break;
default:exit(0);
}}
}
Linked list as a data structure
Advantage of an array over list.
An array implementation allows access to the nth item in a group using a single operation, whereas a list
implementation requires n operation. In a linked list an item is accessed by traversing the list from thebeginning.
Advantage of a list over an array.
In an array if we have to insert an element in the middle then we have to move the elements down tomake room for the new element. Similarly if we have to delete an element from the middle we have to
move the remaining elements up to fill up the gap. Whereas in a linked list insertion and deletion of
elements in the middle can be done without affecting the position of other elements.
insafter(p,x) :The operation of inserting an item x into a list after a node pointed to by p
q=getnode();info(q)=x;
next(q)=next(p);
next(p)=q;
delafter(p,x): Denote the operation of deleting the node following the node pointed by p and assigning
its contents to the variable x.
q=next(p);
x=info(q);next(p)=nex(q);
freenode(q);
Write a C routine(function) to insert an element X at the end of a list pointed by plist
8/3/2019 DSC unit5
8/23
SK UNIT-5
8
Insert_end(struct node *plist , int x){
Struct node *new, *temp;
new=(struct node *)malloc(sizeof (structnode))
new->info=x;
new->link=NULL;
if(plist==NULL)plist=new;
temp= plist;
while(temp->link!=NULL)temp=temp->link;
temp->link=new;
}
Write a function to delete the nodes whose information part contains 4
Delete_four(struct node *first)
{Struct node *temp, *prev, *cur;
If (first==NULL)
{printf(list is empty);
return(first);
}
If (first->info=4)
temp=firstFirst=first->link
Free(temp);
prev=NULL;
temp=first;while (temp!=NULL)
{
If (temp->info==4){
cur=temp;
prev->link=temp->link;
temp=temp->link;}
prev=temp;
temp=temp->link;}
}
Write a C routine to delete the last node in the list.
8/3/2019 DSC unit5
9/23
SK UNIT-5
9
Delete_last(struct node *first){
Struct node *temp,*prev;
If (first==NULL){
Printf(list is empty);
Return(first)
}If(fist->link==NULL)
{
Temp=first;First=NULL;
Free(temp);
Return(first);}
Prev=NULL;
Temp=first;While(temp->link!=NULL)
{Prev=temp;
temp=temp->link;}
Prev->link=NULL;
Free(temp);return(first);
}
Write a C routine to reverse a linked list
Struct node* reverse(struct node *first)
{
Struct node *prev,*cur,*next;
cur=first;
prev=NULL;
while(cur!=NULL)
{
next= cur->linkcur->link=prev;
prev=cur;
cur=next;}
return(prev);
}
Write a C routine to concatenate two list
8/3/2019 DSC unit5
10/23
SK UNIT-5
10
Concat(Struct node * list1,stuct node *list2)
{
struct node* temp;if(list1==NULL)
return(list2)
if(list2==NULL)
return(list1);temp=list1
while(temp->link!=NULL)
temp=temp->link;temp->link=list2
return(list1)
}
Write a C routine to delete a node at a specified position
Struct node* delete_pos(struct node *first, int pos){
Struct node *temp *prev;
int count=1;if(first==NULL)
{
Printf(list is empty);Return;
}
If(pos==1){
First=first->link
return(first);
}temp=first;
prev=NULL;
while(temp!=NULL && count!=pos){
Prev=temp;
Temp=temp->link;
Count++;}
If (temp=NULL)Printf(invalid position);
else
{
Prev->link=temp->link
8/3/2019 DSC unit5
11/23
SK UNIT-5
11
free(temp);}
}
Write a function to delete the nodes whose information part is specified
Struct node *Delete_four(struct node *first, int item){
Struct node *temp, *prev, *cur;
If (first==NULL){
printf(list is empty);
return(first);}
If(first->info==item)
{Temp=first
First=first->linkfree(temp);
return(first);}
prev=NULL;
temp=first;
while (temp!=NULL){
If (temp->info==item)
{cur=temp;
prev->link=temp->link;
temp=temp->link;
return(first);}
prev=temp;
temp=temp->link;}
}
Write a C routine to insert a node at a specified position
Node * insert_pos(int item,node* first)
{int count;
node * temp,*cur,*prev;
temp=(node*)malloc(sizeof(node));if (temp==NULL)
{
8/3/2019 DSC unit5
12/23
SK UNIT-5
12
printf(allocation failed);return(first);
}
temp->info=item;temp->link=NULL;
if(first==NULL&&pos==1)
return temp;
if(first==NULL){
printf("Invalid position\n");
return first;}
if(pos==1)
{temp->link=first;
return temp;
}prev=NULL;
cur=first;count=1;
while(cur!=NULL&&count!=pos){
prev=cur;
cur=cur->link;count++;
}
if(count==pos){
prev->link=temp;
temp->link=cur;return first;
}
printf("Invalid position\n");
return first;}
List implementation of priority queues
To implement a priority queue, when we are inserting elements into the queue we store it in ascendingorder so that the first element deleted is always the smallest element. For a descending priority queue the
elements are stored in descending order so that the first element deleted is always the largest element.
8/3/2019 DSC unit5
13/23
SK UNIT-5
13
To maintain an ordered list, for every insertion we have to compare all the elements. It is not possible totraverse a linked list from the last node. So we dont need the rear pointer here.
Ordered list(struct node *first, int item){
Struct node *temp,*prev,*new;
new=(struct node*)malloc(sizeof(struct node));
new->info=item;new->link=NULL;
if(first==NULL)
return(new);
If (iteminfo)
{New->link=first
first=new
return(first);}
temp=first
prev=NULL;
(temp!=NULL && item>temp->info)
{prev=temp;
temp=temp->link;
}prev->link=new
new->link=temp
return(first);}
Write a C routine to concatenate two ordered list
Struct node* concat(struct node *list1 ,struct node * list2)
{
Struct node *temp1,*temp2,*cur;prev1=NULL
if(list1==NULL)
return(list2)
if(list2==NULL)return(list1);
if(list1->info>list2->info){
temp=list2;
list2=list2->link;temp->link=list1
list1=temp;
8/3/2019 DSC unit5
14/23
SK UNIT-5
14
}temp1=list1;
temp2=list2;
while(temp1!=NULL & temp2!=NULL){
If(temp1->info>temp2->info)
{cur=temp2;
temp2=temp2->link;
prev->link=cur;cur->link=temp1
}
Else{
prev=temp;
temp=temp->link;}
while(temp2!=NULL){
Prev->link=temp2}
Return(list1)
}
Header Nodes
Sometimes an extra node is placed in the front of a list called the header node. This node does not
represent an item in the list . The info part of the header node is often not used or sometimes it may
contain some global information like the number of nodes etc.
Implementing the Header Nodes
When the data type of the header contents is the same as the contents of the node in a list then the headernode can be implemented as just another node in the beginning of the list.
For example
Struct node
{
int info;struct node *link
}
Struct node *head;
If the data type of the header node is different from the contents of the node in list then the header node
can be declared as a separate variable.
For example
8/3/2019 DSC unit5
15/23
SK UNIT-5
15
Struct node
{
Char info;Struct node *link;
};
Struct node h1;
Here h1 can be used as the header node whose info part may contain information like the number of
nodes and its link part will be pointing at the first nodeStruct headstr {
Int length;Struct node *first;
};
Struct headstr h1,h2;
Here h1 and h2 is declared as variables of struct headstr its information part contains the length of the
string and the first contains the address of the first node.
8/3/2019 DSC unit5
16/23
SK UNIT-5
16
Lists in C
Array implementation of Lists
A list can be represented as an array of nodes. The elements are not ordered by the array.each element
will contain within itself a pointer to its successor.
For example a group of 500 nodes may be declared as an array of nodes as follow
#define size 500
Struct node
{int info;
int link;
};Struct node n[size];
}
In this method a pointer to a node is represented by an array index, therefore a pointer is an integerbetween 0 and size-1. The NULL pointer is represented by -1. Her the node is represented as
node[p].information part is represented as node[p].info and the link part is represented as node[p].link.
0
1
2 7 9
3
4 25 205
6
7
8 3 18
9 11 -1
10
11
12
13
14
15 21 4
16
17
18 5 2
19
20 14 -1
21
22
8/3/2019 DSC unit5
17/23
SK UNIT-5
17
In the above example list1 contains 8 which is the position of the first element The info is 3 and the
position of the next element can be found from its link part that is 18 . The elements of list1 are 3 5 7 11
The elements of list2 is 21 25 14.
Initially all the nodes are unused. No lists have been formed yet so all the nodes are in the availablelist.The global variable avail is used to point to the available list.
The available list can be initially organized as follows.
avail=0;for(i=0;i
8/3/2019 DSC unit5
18/23
SK UNIT-5
18
The primitive operations for list are
The insafter that accepts a pointer p to a node and an item x as parameters and then inserts x intoa node following the node pointed to by p.
The delafter(p,&x)-deleted the node following p and stores its conten in x;
Void insafter(int p, int x)
{
int q;if (p==-1)return(invalid insertion)
else{
q=getnode();
node[q].info=x;node[q].link=node[p].link;
node[p].link=q;
}
}
Void delafter(int p, int *px)
{
int q;
if (p=-1)printf(invalid insertions);
else{
Q=node[p].next;
*px=node[q].info;node[p].next=node[q].next;
freenode(q);
}
Limitations of Array implementation
The number of nodes that are needed cannot be predicted when the program is written.
The number of nodes declared remains allocated. If the allocated nodes are not used it cannot beused for any other purpose.
The time required to compute the address of node[p] is more as we have to add p to the base
address. *p is given by the contents of p directly.
Dangling pointer
When a call to the function free(p) is made the storage for *p is freed and makes a subsequent referenceto *p illegal. But actually the value of p is left unchanged even though it is illegal to access it, there is
8/3/2019 DSC unit5
19/23
SK UNIT-5
19
no way to detect the illegality and such a pointer is called a dangling pointer. Therefore it is a goodpractice to explicitly set p to NULL after executing free(p).
Non integer lists
It is not necessary that a node in a linked list should always represent an integer. For example To
represent a collection of strings with a linked list we can declare the node as followsStruct node
{
Char info[50];Struct node *next
};
Here the info part can store a string with 49 characters.
For some applications it may be necessary for a node to store more than one item of information, for
example to maintain the information of a student in a node we can have items like students name,roll
no,marks etc. , such a node can be declared as follows.
Struct stud
{char name[30];
int roll_no;
int m1,m2,m3;
};
Separate C routines must be written to manipulate the lists.
Non homogenous list
Non homogeneous list are those that contains nodes of different types. To represent non homogeneouslist a union can be used. For example
8/3/2019 DSC unit5
20/23
SK UNIT-5
20
#define intgr 1#define flt 2
#define strng 3
Struct node
{
int etype; //represents the data type of the element it can be intgr, flt or string depending on the value
//stored in it
Union {
int ival;
float fval;
char *pval;} element;
Struct node *next;};
Using struct node we can declare nodes whose items may be integer, float or string.
Comparing the Dynamic and Array implementation of Lists
The major disadvantage of dynamic implementation is that it requires more time to call thesystem to allocate and de-allocate memory. It is easier to manage a pre allocated availability list.
The advantage is that the number of nodes are not allocated in advance.
Another advantage is that a reference to *p does not involve the address computation that isnecessary in computing the address of node[p]. To compute the address of node[p] the content of
p must be added to the base address of the array node.
Even if we have more than one list, the lists will not overflow until there is enough storage forthe nodes
Write a C program using dynamic variables to maintain the information of students using linked
list.
#include
#includestruct student
{
char name[20];
int id;int sem;
struct student *link;
};typedef struct student *STUD;
STUD getnode()
{STUD x;
x=(STUD)malloc(sizeof(struct student));
8/3/2019 DSC unit5
21/23
SK UNIT-5
21
if(x==NULL){
printf("Allocation failed\n");
exit(0);}
return x;
}
STUD insert_front(char name[],int id,int sem,STUD first){
STUD temp;
temp=getnode();strcpy(temp->name,name);
temp->id=id;
temp->sem=sem;temp->link=NULL;
temp->link=first;
return temp;}
STUD insert_rear(char name[],int id,int sem,STUD first){
STUD temp,cur;temp=getnode();
strcpy(temp->name,name);
temp->id=id;temp->sem=sem;
temp->link=NULL;
if(first==NULL)return temp;
cur=first;
while(cur->link!=NULL){
cur=cur->link;
}
cur->link=temp;return first;
}
STUD delete_id(int id,STUD first)
{
STUD cur,prev;
if(first==NULL){
printf("List is empty\n");
return first;}
if(id==first->id)
{cur=first;
first=first->link;
8/3/2019 DSC unit5
22/23
SK UNIT-5
22
free(cur);return first;
}
prev=NULL;cur=first;
while(cur!=NULL&&id!=cur->id)
{
prev=cur;cur=cur->link;
}
if(id==cur->id){
prev->link=cur->link;
free(cur);return first;
}
printf("Matching id not found\n");return first;
}
void display(STUD first){
STUD temp;
if(first==NULL){
printf("List is empty\n");
return;}
printf("NAME ID SEM\n");
for(temp=first;temp!=NULL;temp=temp->link){
printf("%s\t%d\t%d\n",temp->name,temp->id,temp->sem);
}
}void main()
{
char name[20];int ch,id,pos,sem;
STUD first=NULL;
clrscr();
for(;;){
printf("1:insert front\n2:insert rear\n3:delete_id\n6:display\n");
printf("Enter the choice\n");scanf("%d",&ch);
if(ch==1||ch==2||ch==3)
{printf("Name\n");scanf("%s",name);
printf("id\n");scanf("%d",&id);
8/3/2019 DSC unit5
23/23
SK UNIT-5
23
printf("Sem\n");scanf("%d",&sem);}
switch(ch)
{case 1:first=insert_front(name,id,sem,first);
break;
case 2:first=insert_rear(name,id,sem,first);
break;
case 3:printf("Enter the id\n");
scanf("%d",&id);first=delete_id(id,first);
break;
case 4:display(first);
break;
default:exit(0);}
}}