01 Linked Lists

DS - DSAA ( Common Topics )
1. Linked Lists
Lists:
In general lists are like arrays that are used to store ordered data.
A List is a linear sequence of data objects of same type.
Or
List is a collection of multiple elements arranged one after another in linear order.
Common operations on list :
Creating an initial list.

Inserting new elements in the list at any position.
Deleting any elements from list.
Displaying i.e. printing elements in list. (usually from 1st to last )
Searching given element in the list.
Arranging elements in the list according value of the elements. (Sorting a
list).
Linked Lists :
(Using Dynamic memory allocation i.e. Node implementation) :
Linked list is an ordered collection of data in which each element holds a

link for the next element in the list.
Each element contains data and the reference for the next element; that is
each element contains two parts data and a link.
The data part holds the useful information ( i.e. the data to be processed).
The link is used to chain the list elements together.
An element that holds Data and a Link for other elements is called a
Node.
According to type of list there can be one or two links in each node.
Its dynamic structure and any number of Nodes can be added to it. It uses
Dynamic memory allocation to create new Nodes.
Thus linked list is a linear collection of Nodes where each node holds link for next
Node in the list. The first node holds link for the second node, second holds link
for third and so on. The last Node holds Null link to indicate its a last element in
the list.
Each node consists of two main fields: Information i.e. Data and Link i.e. Reference for next element.
Data
Link
Node
Fig. 1
Notes prepared by: Santosh Kabir

Mobile : 98336 29398
1.Linke d Lis ts
1 of 24
www.santoshkabirsir.com
For example, a linked list created to store student information may have students roll no, name and height as
an information field in a node.
Link is nothing but a reference i.e. memory address of a node. In C programs link is a Pointer for a node.
Types of Linked Lists :

Singly linked list :
Singly linked list consists of one or more nodes with each node holding
reference for a next element in the list.
The last node holds a null reference to indicate end of a list.
The reference for the first node is kept in a reference variable called root.
New nodes can be added to the list and any existing nodes can be removed.
One can traverse the list from in forward direction in the list.
Following figure shows a Singly linked list with four elements i.e. nodes with data
A, B, C and D. A is first node and D is a last node.
Black filled circles indicate links to next nodes and hollow circle indicates null link.
A
Circular Linked List :
Circular linked list consists of one or more nodes with each node holding
reference (pointer) for a next element in the list.
The last node holds a reference to the root i.e. first node of a list.
One can traverse the list in forward direction but circularly.
Following figure shows a Circular linked list with four elements i.e. nodes with
data A, B, C and D. A is first node and D is a last node.
Black filled circles indicate links to next nodes.
A

Mobile : 98336 29398
1.Linke d Lis ts
2 of 24
Doubly Linked List :
Doubly linked list consists of one or more nodes with each node holding
references (pointers) for next and previous elements in the list.
Each node has two link fields ( i.e. two pointers). The pointers are called as
forward (next) pointer and backward (previous) pointer.
The forward pointer of last node and backward pointer of root hold Null.
One can traverse the list in forward direction as well as backward direction.
Thus, from any nth node in a list we can move towards root or towards end
of list. Thus, the list is more flexible.
Following figure shows a Doubly linked list with four elements i.e. nodes with data
A, B, C and D. A is first node and D is a last node.
Black filled circles indicate links to next/previous nodes.
A
Singly Linked List :

Adding an element (node) to the list:
The new node will hold null link to indicate its a last node. An algorithm for
adding a node to a singly linked list is given below,
A-1
1.
2.
3.
4.
Input the data to be stored in the node.

Allocate memory for new node.
Store data in the information field and null in the link field in a new node.
If list is empty (if its a first node)
Store reference for the node in variable, root.
6. Else
Put reference for the new node in the link field of currently last node.
7. Record new node as last node of List
Displaying linked list elements:

To display the nodes in a list first get the reference of root of the list. Display the
contents (information field) of the root node. Read the link field of the node, which
gives reference for the next node. Display the contents of the node given by this
link. Repeat the process till end of list is reached.
Mobile : 98336 29398
1.Linke d Lis ts
3 of 24
Algorithm for displaying the list contents is as follows,

A2
1. Read the root into a reference variable (pointer)
2. While pointer is not Null repeat following.
a. Display contents of node referred by the pointer
b. Update the pointer to pointer value in current node.
Removing a node from a list:

Here, input the node value to remove (i.e. delete). Find the node. Then link the
next node to the previous node of the list. e.g. to remove fourth node of linked list,
one has link the third node to fifth node.
There are three cases: i) Remove first node, ii)Remove last node and iii) Remove
intermediate node. The following algorithm shows all the cases.
Algorithm to remove an item from the list,
A-3
1. Input the node value to be deleted
2. Read the root pointer
3. While pointer is not Null repeat following
a. If node to deleted is found, then,
Stop the search
b. Else
Read pointer for next node
4. If required node is found in above step 3 then
i. If it is root node
Update root of list to refer the second node in the list
ii. Else if its a last node then
Make second last node as last node
(i.e. perform following operations)
Put Null in the link field of previous node.
iii. Else
Update link in the previous node to address of the next node
iv. Free the node to be deleted.
5. If node not found display (error) message
Inserting Node (before given node):

Node can be inserted in the list at whatever position without making many
changes in the existing list.
To insert a node at the place of an node A, existing in a list: Create a new node
(allocate a new node) in memory, and update the links in the corresponding
nodes. e.g. to insert B node between A and C, one has to link A to B and B (new
node) to C.

Mobile : 98336 29398
1.Linke d Lis ts
4 of 24

If a node is inserted at the beginning of a list the new node becomes a root of the
list and the previous root node of the list becomes a second node.
An algorithm to insert a node in the list is as follows,
A-4
1. Read root pointer of list
2. Input the node value before which new node will be inserted
3. Input value for a new node
4. While pointer note null (i.e. not end of a list) repeat following
a. If the node found where new node is to be inserted then
Stop the search
b. Else
Read pointer for next node
5. If node is found in step 4, then
i. Allocate memory for new node
ii. Store information in the node and link for the current node
iii. If inserting at the beginning of list then
Make new node as root and original root node as second node
iv. Else
Update pointer in previous node to refer to new node and pointer in new
node to the refer to the node before which new node was inserted.
6. If node not found display (error) message.
Note :
Complete program for Singly Linked List will be Discussed and Written in class.
Static and Dynamic implementation of Linked List :

Linked list can be formed by creating linking nodes in linear order. This is also
called a dynamic implementation of Lists.
In static implementation, a list can be created using an array. Its a simplest
implementation of lists. List items can be stored in an array in continuous
elements and any item in the list can be accessed using syntax
array_name[index].
A new element can be added at the end of the existing list by just keeping track of the last element index.
Now lets see the Insert operation. Suppose we have to insert an item at Nth position. To do this we must shift
elements from Nth position till the last element in the list, by one position towards the end of the array.
Similarly, to delete an element at Nth position we have to shift all the elements from (N+1)th position till the end
of the list, towards the beginning of array by one.
Thus, to insert or delete an item in a list, lot of movement of data is required which is always undesirable.
Drawbacks of array implementation of a List are as follows,

An array is created taking into consideration certain number of elements.
The allocated memory storage space may be wasted, if lesser number of elements
are used i.e. if entire array is not utilized.

Mobile : 98336 29398
1.Linke d Lis ts
5 of 24

The list cant grow in its size beyond the size of the declared array, if required,
during the program execution. Thus, in some cases, when a program is executing
the memory space wont be enough to work with the actual number of elements.
Operations such as insertion and deletion of an item at a certain location in a list
involve a lot of data movement.
All the above operations finally lead to inefficient use of memory.
Also these operations require time-consuming algorithms.
The advantages of Linked lists over arrays are,

The list can grow and shrink in size during program execution. Thus the
maximum limit on the size of the list will not be a problem while adding and
inserting items in the list.
Thus, an exact amount of memory space is utilized by the List. Wastage of extra
memory or shortage of memory will not occur.
Insertion and deletion of a list item does not involve movement of data.
Drawbacks: The place (node) at which these operations are done in the list are not
directly accessible like in arrays where using an array index programmer can
access any item in the list directly.
Secondly, every element holds a link field within it, taking extra memory.
ADT (Abstract Data Type):

Data abstraction basically implies hiding data from user.
Abstract Data Type can be defined as a package of Data declaration and the
operations that are meaningful on the data.
ADT mentions what operations can be performed on the data. But exactly how
the operations are performed is hidden from user of the data.
Thus, ADT is a useful tool for specifying logical properties of a data type(Or a
particular concept that a programmer want to implement). While defining an ADT
we are not concerned with the time or space efficiency of the functionalities.
Also, ADT is not concerned with how a particular function is implemented. It just
explains what different operations are possible with the data type.
Linked List ADT:

Data: Linked list holds multiple elements that are Nodes. Each node holds one
information and link to at least one (mostly a link to next node ) other node in the
list.
Oparations:
Add : Adding a new node to the list.
Remove: Removing a node from the linked list.
Insert : Insert a new node at the given positioning the list.
Display: Displaying the information the nodes of the linked list.
Mobile : 98336 29398
1.Linke d Lis ts
6 of 24
Circular Linked List:

The operations on circular linked list and their algorithms are follows.
A structure for a node of a list will be is same as that discussed in singly linked
list. The reference variables root and last will be also required.
Adding a node:
An algorithm for adding a node to the circular linked list is same as that for
simple linked list (See algorithm A-1 for linear linked list). One difference is that
the link in a newly allocated node will hold reference for the first node in the list.
Thus, in the algorithm add new step at the end as follows,
Put root pointer in new nodes link.
Displaying nodes in the linked list:

Algorithm for displaying the list contents is as follows,
A5
2. Repeat following
i. Display contents of node referred by the pointer
ii. Update pointer to the next node
iii. Repeat 2.i , 2.ii till the pointer is not root pointer.
Removing a node from a list:

There
1.
2.
3.
are three cases in removing a node from a list.

Removing a first node:
Removing a last node:
These notes are also available at :
Removing any other node:
A-6
1. Read the value of node to be deleted
2. Read the root node pointer
3. Repeat following steps
a. If the pointer refers to the Node to be deleted then
stop the search
b. Else
Update pointer to refer to next node
c. If root node is not reached then go to step 3.a
4. If required node is found in step 3 then
i. If it is first node
Update root of list to refer to second node
Update the link in the last node to new root

Mobile : 98336 29398
1.Linke d Lis ts
7 of 24

ii.
Else if its a last node

Update link in a second last node to root pointer
iii. Else
Put pointer of next node in the previous node
iv. De-allocate the deleted node
5. If node not found print message
Inserting a node (before given node) :

An algorithm to insert an item in the list is as follows,
A-7
1.
2.
3.
4.
Input the value of node where new node is to be inserted

Input value for new node
Read the root pointer
Repeat following steps
a. If the pointer refers to the node where a new node is to be inserted then
i. stop search
b. Else
Update pointer to refer to next node.
c. If pointer dont refer to root, go to 4.a
5. If required node is found in step 4
a. Allocate memory for new node
b. Put the value in the new node
c. Store pointer for current node in the new node
c. If current node is first node
Update root to refer to a new node.
Update pointer in the last node to refer to the new node.(new root)
d. Else
Update link in the previous node to refer to a new node
6. If node not found print message
Program for Circular linked list

#include<stdio.h>
#include<conio.h>
#include<alloc.h>
struct Node
{
int data;
struct Node *next;
};
struct Node
*root=NULL, *last=NULL;
// Function prototypes for ADT
void CreateList( int n );

Mobile : 98336 29398
1.Linke d Lis ts
8 of 24

void
void
void
void
Display( void );
InsertBefore( int p, int v);
InsertAfter( int p, int V);
DeleteNode(int p);
// Functions for Circular linked list
void CreateList( int n )

{
int i, v;
Node *nw;
// Create a root node
printf("Enter a node value:");

scanf("%d", &v);
root = (struct Node*) malloc( sizeof(struct Node) );
root->data = v;
root->next = root;
last = root;
// Create remaining n-1 nodes
for( i=1; i<n; i++)

{
scanf("%d", &v);
nw = (struct Node*) malloc( sizeof(struct Node) );
nw->data = v;
nw->next = root;
last->next = nw;
last = nw;
}
}
void Display()
{
struct Node *r;
if( root == NULL )
printf("List is empty\n");
else
{
r = root;
printf("Nodes...\n");
do
{
printf("%d\t", r->data);
r = r->next;
} while( r!= root );
printf("\n");
}
}
Mobile : 98336 29398
1.Linke d Lis ts
9 of 24
void InsertBefore( int p, int v)

{
struct Node *cur, *prev, *nw;
int found = 0;
cur = root;
do
{
if( cur -> data == p )
{
found = 1;
break;
}
else
{
prev = cur;
cur = cur->next;
}
}while( cur != root );
if( found )
{
nw = (struct Node*) malloc( sizeof( struct Node) );
nw->data = v;
if( cur == root )
{
nw->next = root;
root = nw;
last->next = root;
}
else
{
prev->next = nw;
nw->next = cur;
}
}
}
void InsertAfter( int p, int v)
{
struct Node *cur,*nxt, *nw;
int found =0;
cur = root;
do
{
Mobile : 98336 29398
1.Linke d Lis ts
10 of 24

{
found=1;
break;
}
else
cur = cur->next;
if( found )
{
nw->data = v;
if( cur->next == root )
{
cur->next = nw;
nw->next = root;
last = nw;
}
else
{
nxt = cur->next;
cur->next = nw;
nw->next = nxt;
}
}
}
void DeleteNode( int p )
{
struct Node *cur, *prev;
int found=0;
cur = root;
do
{
{
found = 1;
break;
}
else
{
prev = cur;
cur = cur->next;
}
if( found )
{
if( cur == root )
Mobile : 98336 29398
1.Linke d Lis ts
11 of 24

{
root = root->next;
last->next = root;
}
else if( cur->next == root )
{
prev->next = root;
last = prev;
}
else
{
prev->next = cur->next;
}
free( cur );
}
}
Note : main() function will be same as that of singly linked list. Refer to program written in class.
Doubly Linked list :

Since each node holds link for next and previous nodes, the node structure is
defined with two node pointers. ( refer to Doubly linked list program )
Adding a node to the list:

Algorithm for adding a new node to a doubly linked list is given below.
A-8
1.
2
3.
4.
Input the value to be stored in a new node.

Allocate memory for new node
Store the value in information part and null in both the pointers in the new node.
If the list is empty
Store reference for the node in root poiter
6. Else
Put pointer of the new node in the forward link of last node.
Put pointer for the last node in the backward link of the new node.
7. Put pointer for a new node in last pointer.
Displaying linked list nodes:

Refer to Display algorithm of Singly linked list.
Removing a node:
Algorithm to remove an item from the list,
A- 9
Mobile : 98336 29398
1.Linke d Lis ts
12 of 24

1. Read the value of the node to be removed
3. While not end of a list do ..
a. If value found in current node
Stop the search
b. Else
Update pointer to refer to next node
4. If required node is found in step 3 then
i. If it is root node of list
Update root of list to refer to second node
Put null in the backward link of new root node
ii. Else if its a last node
Update forward link of second last node to null
Update the last pointer to refer to the second last node.
iii. Else
Update forward link in previous node to refer to next node
Update backward link in next node to refer to previous node
iv. Stop the loop
5. If node not fond display message.
Inserting a Node (before given node) :

An algorithm to insert a node in the list is as follows,
A- 10
1. Input the value of the node (key) where new node will be inserted.
2. input a new data for a new node to insert.
4. While not end of a list do ..
a. If key found in current node
Stop the search
b. Else
Update the pointer to refer to next node
4. If key is found in step 4 then,
i. Allocate memory for new node
ii. Store value in new node and put the links for previous and current
nodes in the new node.
iii. If new node to be inserted at the beginning
Update backward link of the root node the new node pointer.
Update root pointer to refer to the new node
iv. Else
Update Forward link of previous node to refer to new node
Update Backward link of current node to refer to new node
b. If node not found then display error message.
Program for Doubly Linked list:

#include<stdio.h>
#include<conio.h>
#include<alloc.h>
Mobile : 98336 29398
1.Linke d Lis ts
13 of 24

struct Node
{
int data;
struct Node *prev, *next;
};
struct Node
void
void
void
void
void
*root=NULL, *last=NULL;
CreateList( int n );
Display( void );
InsertBefore( int p, int v);
InsertAfter( int p, int V);
DeleteNode(int p);
void CreateList( int n )

{
int i, v;
Node *nw;
// Create a root node
scanf("%d", &v);
root = (struct Node*) malloc( sizeof(struct Node) );
root->data = v;
root->next = root->prev = NULL;
last = root;
// Create remaining n-1 nodes
for( i=1; i<n; i++)
{
scanf("%d", &v);
nw = (struct Node*) malloc( sizeof(struct Node) );
nw->data = v;
nw->next = NULL;
nw->prev = last;
last->next = nw;
last = nw;
}
void Display()
{
struct Node *r;
if( root == NULL )
printf("List is empty\n");
else
{
r = root;
printf("Nodes...\n");
while( r != NULL )
{
printf("%d\t", r->data);
Mobile : 98336 29398
1.Linke d Lis ts
14 of 24

r = r->next;
}
printf("\n");
}
}
void InsertBefore( int p, int v)
{
struct Node *cur, *pr, *nw;
int found = 0;
cur = root;
while( cur != NULL )
{
{
found = 1;
break;
}
else
{
pr = cur;
cur = cur->next;
}
}
if( found )
{
nw->data = v;
if( cur == root )
{
nw->next = root;
nw->prev = NULL;
root = nw;
}
else
{
pr->next = nw;
nw->prev = pr;
nw->next = cur;
cur->prev = nw;
}
}
}
void InsertAfter( int p, int v)
{
struct Node *cur,*nxt, *nw;
int found = 0;
cur = root;
{
{
found = 1;
break;
Mobile : 98336 29398
1.Linke d Lis ts
15 of 24
}
else
cur = cur->next;
if( found )
{
nw->data = v;
if( cur->next == NULL )
{
cur->next = nw;
nw->prev = cur;
nw->next = NULL;
last = nw;
}
else
{
nxt = cur->next;
cur->next = nw;
nw->prev = cur;
nw->next = nxt;
}
}
}
void DeleteNode( int p )
{
struct Node *cur, *pr, *nxt;
int found =0;
cur = root;
{
{
found =1;
break;
}
else
{
pr = cur;
cur = cur->next;
}
}
if( found )
{
if( cur == root )
{
root = root->next;
root->prev= NULL;
}
else if( cur->next == NULL )
{
pr->next = NULL;
Mobile : 98336 29398
1.Linke d Lis ts
16 of 24
last = pr;
}
else
{
nxt = cur->next;
pr->next = nxt;
nxt->prev = pr;
}
free( cur );
Linked List using Array :

In this implementation of list an array is used to hold elements i.e. Nodes of linked
list.
Each element of the array holds data and link for the next element (i.e. Node) in
the list. Links are the array indexes.
Last element of the list holds -1 as index to indicate end of list.
Deleting and inserting nodes requires updating the links i.e. array indexes
properly.
This requires a bit complex coding.
No pointers and dynamic memory allocations.
Drawback is that the Size of the list is limited to array size. And fixed amount
memory will be used whatever number of nodes are really present.
Following figure shows linked list with four elements (10,20,30,40).
Array size is Six. Next variable in each node holds link for (index of) the next
element in the list.
data
next
10
20
30
40
-1
Program for Linked list using Array is given below :

#include<stdio.h>
#include<conio.h>
Mobile : 98336 29398
1.Linke d Lis ts
17 of 24

#include<ctype.h>
#define Size 6
struct Node
{
int data;
int next; // holds array-index of next node in the list
};
// Global variables to maintain list.
struct Node A[Size]; // Array to hold Nodes i.e. linked list
int first, avail, last;

void Initialize( )
{
int i;
first = last = -1;
// index of first and last item in the list.
avail= 0;
// index of next available element.
for(i=0; i< Size -1 ; i++) // Initialize all the nodes to hold next index
{
A[i].next = i+1; // link each element of array to next
}
A[ Size-1].next = -1 ; // next= -1 indicates last item
}
int GetNode()
{
int p;
p = avail;
avail = A[avail].next;
if(first== -1)
first=0;
return p;
// if list is empty.. first element is root
void AddNode(int v)
{
int p;
p = GetNode();
A[p].data = v;
last = p;
}
void InsertAfter(int pos, int val)
{
int p;
if(pos == -1 || pos == avail)
printf("\n Invaliid position ...\n");
else if(pos == last)
AddNode(val);
else
{
p = GetNode();
A[p].data = val;
A[p].next = A[pos].next;
Mobile : 98336 29398
1.Linke d Lis ts
18 of 24

A[pos].next = p;
A[last].next = avail;
}
void FreeNode(int p)
{
if( p == first )
{
first = A[p].next;
}
A[p].next =avail;
avail = p;
}
int DeleteNode(int pos)
{
int cur=first, prev=-1;
int v; // to store value at given pos.
while(cur != pos)
{
prev = cur;
cur = A[cur].next;
}
v = A[pos].data;
A[prev].next = A[pos].next;
FreeNode(pos);
A[last].next = avail;
return(v);
}
void Display()
{
int r=first;
if( r != -1)
{
printf("\nList elements...\n");
while( r != avail)
{
printf("%d\t", A[r].data );
r = A[r].next;
}
}
else
{
printf("\nList is empty ...\n");
}
}
void main()
{
int d;
Mobile : 98336 29398
1.Linke d Lis ts
19 of 24

char a,ch;
int cno;
clrscr();
Initialize();
printf(" -- Linked list [Array implementation]--\n");
while ( 1 ) // always true
{
printf("\n\n== MAIN MENU ==\n");
printf("\nAdd
- a\n");
printf("Show list - s\n");
printf("Remove
- r\n");
printf("Insert
- i\n");
printf("Quit
- q\n\n");
printf("Your choice:");
scanf("%c", &ch);
printf("\n\n");
switch(tolower(ch))
{
case 'a':
while(1)
{
printf("Enter no:");
scanf("%d",&d);
fflush(stdin);
AddNode(d);
printf("Press 'y' to continue...");
scanf("%c", &a);
fflush(stdin);
if(tolower(a) != 'y' )
break;
}
break;
case 's' : Display();
break;
case 'i' :
printf("\nInsert after what pos :");
scanf("%d",&cno);
printf("Enter new num :");
scanf("%d",&d);
fflush(stdin);
InsertAfter(cno, d);
break;
case 'r':
printf("\nWhich node to remove .. enter pos:");
scanf("%d",&cno);
d = DeleteNode(cno);
printf("Info. in del. node:%d\n", d);
break;
case 'q':
return;
Mobile : 98336 29398
1.Linke d Lis ts
20 of 24

default:
printf("Invalid choice...\n");
}
}
getch();

Mobile : 98336 29398
1.Linke d Lis ts
21 of 24

Some additional functions on Linked lists:
1. Displaying singly linked list (Recursive function):
void displayRec(struct Node *r)
{
if( r != NULL )
{
printf(%d\t, r->data);
displayRec( r->next ); // recursive call with new link
}
}
The above function is called with root node of the list i.e. link for the first node as
a parameter.
e.g. displayRec ( root );
2. Recursive function to print Singly linked list in Reverse order:
void displayRev(struct Node * r)
{
if( r != NULL )
{
displayRev( r->next ); // recursive call with new link
}
printf(%d\t , r->data);
}
The above function is called with root node of the list i.e. link for the first node as
a parameter.
e.g. displayRev (root );
3. Comparing two linked lists:
The function compares the linked lists passed as arguments. Return 1 if they have
same values in all nodes and lengths are also same. Function parameters are root
pointers of the lists to be compared.
int equals( struct Node *r1, struct Node *r2 )
{
int v = 1;
if( r1== NULL && r2 == NULL )
return 1;
else
{
while( r1 != NULL )
{
if( r2 == NULL )
{
v = 0;
break;
}
if( r1->data != r2->data )
{
V = 0;
break;
Mobile : 98336 29398
1.Linke d Lis ts
22 of 24

}
r1 = r1->next;
r2 = r2->next;
}
if( r1 != NULL || r2 != NULL )
v= 0;
}
return v;
}
4. Creating a Sorted Linked list:
The sorted linked stores nodes in the ascending order of values of the nodes. i.e.
Node with the smallest value will be the first element of the list and that with the
largest value will be the last node of the list.
Following function inserts a new node at the proper position in the list so that the
list nodes are in the ascending order. If the new node has smallest value it will be
inserted as a root node and a node value is larger than the other nodes the new
node is added at the end of list. ( Assume singly linked list)
void createSortedList(int val)
{
struct Node *cur=NULL, *prev=NULL, *nw;
nw = malloc(sizeof(struct Node));
nw->data = val;
nw->next = NULL;
if(root==NULL) // if list is empty
{
root=nw;
last=nw;
}
else if( val > last->data) // if value is greater than last node value
{
last->next =nw;
last = nw;
}
else
{
cur=root;
while(cur->data < val) // move in the list to get proper position
{
prev=cur;
cur=cur->next;
}
if(cur==root) // to insert node at beginning
{
nw->next = root;
root=nw;
}

Mobile : 98336 29398
1.Linke d Lis ts
23 of 24

else
// insert node at any other position
{
prev->next = nw;
nw->next = cur;
}
}
}
5. Reversing a singly Linked list without any additional node allocations:
Assume root and last are the links for first and last nodes of a linked list.
void reverse()
{
if( root != NULL )
{
struct Node * cur, *prev= NULL , *nxt= NULL, *t;
cur = root;
{
nxt = cur->next;
cur->next = prev;
prev =cur;
cur =nxt;
}
t=root;
Email : santoshkabir@yahoo.com
root=last;
last=t;
Visit :
}
( for batch timetables, QP soln etc. )
}
=====000000=====
Classes for Engg. students:

FE SPA
Sem II
SE DS (Comp) , DSAA ( IT ) Sem III

OOPM (Java) ( Comp, IT) Sem III
Web Programming. (IT )
Sem IV
(JSP, C#, ASP.Net, PHP etc)
* With practicals *
By Santosh Kabir sir.
Contact: 98336 29398

Andheri, Dadar, Thane

Mobile : 98336 29398
1.Linke d Lis ts
24 of 24

01 Linked Lists

Diunggah oleh

Informasi Dokumen

Deskripsi Asli:

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

01 Linked Lists

Diunggah oleh

Hak Cipta:

Format Tersedia

DS - DSAA ( Common Topics )

Common operations on list :

Creating an initial list.

Linked list is an ordered collection of data in which each element holds a

Notes prepared by: Santosh Kabir

DS - DSAA ( Common Topics )

Types of Linked Lists :

Circular Linked List :

Notes prepared by: Santosh Kabir

DS - DSAA ( Common Topics )

Doubly Linked List :

Singly Linked List :

Input the data to be stored in the node.

Displaying linked list elements:

DS - DSAA ( Common Topics )

Algorithm for displaying the list contents is as follows,

Removing a node from a list:

Inserting Node (before given node):

Notes prepared by: Santosh Kabir

DS - DSAA ( Common Topics )

Static and Dynamic implementation of Linked List :

Drawbacks of array implementation of a List are as follows,

Notes prepared by: Santosh Kabir

DS - DSAA ( Common Topics )

The advantages of Linked lists over arrays are,

ADT (Abstract Data Type):

Linked List ADT:

DS - DSAA ( Common Topics )

Circular Linked List:

Displaying nodes in the linked list:

Removing a node from a list:

are three cases in removing a node from a list.

Notes prepared by: Santosh Kabir

DS - DSAA ( Common Topics )

Else if its a last node

Inserting a node (before given node) :

Input the value of node where new node is to be inserted

Program for Circular linked list

// Function prototypes for ADT

void CreateList( int n );

DS - DSAA ( Common Topics )

// Functions for Circular linked list

void CreateList( int n )

printf("Enter a node value:");

for( i=1; i<n; i++)

DS - DSAA ( Common Topics )

void InsertBefore( int p, int v)

DS - DSAA ( Common Topics )

DS - DSAA ( Common Topics )

Doubly Linked list :

Adding a node to the list:

Input the value to be stored in a new node.

Displaying linked list nodes:

DS - DSAA ( Common Topics )

Inserting a Node (before given node) :

Program for Doubly Linked list:

DS - DSAA ( Common Topics )

void CreateList( int n )

DS - DSAA ( Common Topics )

DS - DSAA ( Common Topics )

DS - DSAA ( Common Topics )

Linked List using Array :

Program for Linked list using Array is given below :