LINKED LISTS

(1)

(2)

INTRODUCTION

• A linked list in simple terms is a linear collection of data elements. These data elements

are called nodes.

• Linked list is a data structure which in turn can be used to implement other data

structures. Thus, it acts as building block to implement data structures like stacks,

queues and their variations.

• A linked list can be perceived as a train or a sequence of nodes in which each node

contain one or more data fields and a pointer to the next node.

1 2 3 4 5 6 7 X

START

In the above linked list, every node contains two parts- one integer and

the other a pointer to the next node. The left part of the node which

contains data may include a simple data type, an array or a structure.

The right part of the node contains a pointer to the next node (or address

of the next node in sequence). The last node will have no next node

(3)

INTRODUCTION

contd.

• Linked list contains a pointer variable, START which stores the address of the first node in

the list.

• We can traverse the entire list using a single pointer variable START. The START node will

contain the address of the first node; the next part of the first node will in turn store the

address of its succeeding node.

• Using this technique the individual nodes of the list will form a chain of nodes. If START =

NULL, this means that the linked list is empty and contains no nodes.

• In C, we will implement a linked list using the following code:

• struct node

• {

• int data;

• struct node *next;

• };

(4)

1 DATA NEXT H 4 E 7 L 8 L 10 O -1 1 2 3 4 5 6 7 8 9 10 START

START pointing

to the first

element of the

linked list in

memory

9 AVAIL

If we want to add a node to an already existing linked list in

the memory, we will first find any free space in the memory

and then use it to store the information.

The operating system maintains a free pool which is a linked

list of a of all free memory cells. It maintains a pointer

variable AVAIL which stores the address of the first free

space.

When you delete a node from the linked list, the operating

system adds the freed memory to the free pool.

The operating system will perform this operation whenever

it finds the CPU idle or whenever the programs are falling

short of memory. The operating system scans through all

the memory cells and mark the cells that are being used by

some or the other program. Then, it collects all those cells

which are not being used and add their address to the free

pool so that it can be reused by the programs. This process

is called garbage collection. The whole process of collecting

unused memory cells (garbage collection) is transparent to

the programmer.

(5)

Singly Linked List

• A singly linked list is the simplest type of linked list in which every node

contains some data and a pointer to the next node of the same data type. By

saying that the node contains a pointer to the next node we mean that the

node stores the address of the next node in sequence.

1 2 3 4 5 6 7 X

START

Algorithm for traversing a linked list

Step 1: [INITIALIZE] SET PTR = START

Step 2: Repeat Steps 3 and 4 while PTR != NULL Step 3: Apply Process to PTR->DATA

Step 4: SET PTR = PTR->NEXT [END OF LOOP]

(6)

Algorithm to print the information stored in each node of the linked list

Step 1: [INITIALIZE] SET PTR = START

Step 2: Repeat Steps 3 and 4 while PTR != NULL Step 3: Write PTR->DATA

Step 5: EXIT

Algorithm to print the number of nodes in the linked list

Step 1: [INITIALIZE] SET Count = 0 Step 2: [INITIALIZE] SET PTR = START

Step 3: Repeat Steps 4 and 5 while PTR != NULL Step 4: SET Count = Count + 1

(7)

Algorithm to search an unsorted linked list

Step 1: [INITIALIZE] SET PTR = START Step 2: Repeat Steps 3 while PTR != NULL Step 3: IF VAL = PTR->DATA

SET POS = PTR Go To Step 5 ELSE SET PTR = PTR->NEXT [END OF IF] [END OF LOOP] Step 4: SET POS = NULL Step 5: EXIT 1 7 3 4 2 6 5 X PTR 1 7 3 4 2 6 5 X PTR 1 7 3 4 2 6 5 X PTR 1 7 3 4 2 6 5 X PTR

(8)

1 7 3 4 2 6 5 X

START

Algorithm to insert a new node in the beginning of the linked list

Step 1: IF AVAIL = NULL, then Write OVERFLOW

Go to Step 7 [END OF IF]

Step 2: SET New_Node = AVAIL Step 3: SET AVAIL = AVAIL->NEXT Step 4: SET New_Node->DATA = VAL Step 5: SET New_Node->Next = START Step 6: SET START = New_Node

Step 7: EXIT

(9)

Algorithm to insert a new node at the end of the linked list

Step 2: SET New_Node = AVAIL Step 3: SET AVAIL = AVAIL->NEXT Step 4: SET New_Node->DATA = VAL Step 5: SET New_Node->Next = NULL Step 6: SET PTR = START

Step 7: Repeat Step 8 while PTR->NEXT != NULL Step 8: SET PTR = PTR ->NEXT

[END OF LOOP]

Step 9: SET PTR->NEXT = New_Node Step 10: EXIT 1 7 3 4 2 6 5 X START, PTR 1 7 3 4 2 6 5 9 X PTR START

(10)

Algorithm to insert a new node after a node that has value NUM Step 1: IF AVAIL = NULL, then

Write OVERFLOW Go to Step 12 [END OF IF]

Step 2: SET New_Node = AVAIL Step 3: SET AVAIL = AVAIL->NEXT Step 4: SET New_Node->DATA = VAL Step 5: SET PTR = START

Step 6: SET PREPTR = PTR

Step 7: Repeat Step 8 and 9 while PREPTR->DATA != NUM Step 8: SET PREPTR = PTR

Step 9: SET PTR = PTR->NEXT [END OF LOOP]

Step 10: PREPTR->NEXT = New_Node Step 11: SET New_Node->NEXT = PTR Step 12: EXIT 5 1 7 3 4 2 6 X START, PTR, PREPTR 1 7 3 4 2 6 5 X START PREPTR PTR 1 7 3 9 4 2 6 5 X START

(11)

Algorithm to delete the first node from the linked list

Step 1: IF START = NULL, then Write UNDERFLOW Go to Step 5 [END OF IF]

Step 2: SET PTR = START

Step 3: SET START = START->NEXT Step 4: FREE PTR Step 5: EXIT 1 7 3 4 2 6 5 X 7 3 4 2 6 5 X START START

(12)

Algorithm to delete the last node of the linked list

Step 3: Repeat Step 4 and 5 while PTR->NEXT != NULL Step 4: SET PREPTR = PTR

Step 6: SET PREPTR->NEXT = NULL Step 7: FREE PTR Step 8: EXIT 1 7 3 4 2 6 5 X START, PREPTR, PTR 1 7 3 4 2 6 X 5 X PREPTR PTR START

(13)

Algorithm to delete the node after a given node from the linked list

Step 2: SET PTR = START Step 3: SET PREPTR = PTR

Step 4: Repeat Step 5 and 6 while PRETR->DATA != NUM Step 5: SET PREPTR = PTR

Step7: SET TEMP = PTR->NEXT

Step 8: SET PREPTR->NEXT = TEMP->NEXT Step 9: FREE TEMP

Step 10: EXIT 1 7 3 4 2 6 5 X START, PREPTR, PTR 1 7 3 4 2 6 5 X PREPTR PTR START 1 7 3 4 2 6 5 X START 1 7 3 4 6 5 X START

(14)

Circular Linked List

• In a circular linked list, the last node contains a pointer to the first

node of the list. We can have a circular singly listed list as well as

circular doubly linked list. While traversing a circular linked list, we

can begin at any node and traverse the list in any direction forward

or backward until we reach the same node where we had started.

Thus, a circular linked list has no beginning and no ending.

1 2 3 4 5 6 7

(15)

Algorithm to insert a new node in the beginning of circular the linked list

Step 2: SET New_Node = AVAIL Step 3: SET AVAIL = AVAIL->NEXT Step 4: SET New_Node->DATA = VAL Step 5: SET PTR = START

Step 6: Repeat Step 7 while PTR->NEXT != START Step 7: PTR = PTR->NEXT

Step 8: SET New_Node->Next = START Step 8: SET PTR->NEXT = New_Node Step 6: SET START = New_Node Step 7: EXIT 1 7 3 4 2 6 5 START, PTR 1 7 3 4 2 6 5 START PTR 9 1 7 3 4 2 6 5 START

(16)

Algorithm to insert a new node at the end of the circular linked list

Step 2: SET New_Node = AVAIL Step 3: SET AVAIL = AVAIL->NEXT Step 4: SET New_Node->DATA = VAL Step 5: SET New_Node->Next = START Step 6: SET PTR = START

Step 7: Repeat Step 8 while PTR->NEXT != START Step 8: SET PTR = PTR ->NEXT

[END OF LOOP]

Step 9: SET PTR ->NEXT = New_Node Step 10: EXIT

1 7 3 4 2 6 5

START, PTR

1 7 3 4 2 6 5 9

(17)

Algorithm to insert a new node after a node that has value NUM

Step 6: SET PREPTR = PTR

Step 7: Repeat Step 8 and 9 while PTR->DATA != NUM Step 8: SET PREPTR = PTR

Step 10: PREPTR->NEXT = New_Node Step 11: SET New_Node->NEXT = PTR Step 12: EXIT 1 7 3 4 2 6 5 START, PTR, PREPTR 1 7 3 4 2 6 5 9 START PRE PTR PTR 1 7 3 9 4 2 6 5

(18)

Algorithm to delete the first node from the circular linked list

Step 1: IF START = NULL, then Write UNDERFLOW Go to Step 8

[END OF IF]

Step 3: Repeat Step 4 while PTR->NEXT != START Step 4: SET PTR = PTR->NEXT

[END OF IF]

Step 5: SET PTR->NEXT = START->NEXT Step 6: FREE START

Step 7: SET START = PTR->NEXT Step 8: EXIT 1 7 3 4 2 6 5 START, PTR 1 7 3 4 2 6 5 START PTR 7 3 4 2 6 5 START

(19)

Algorithm to delete the last node of the circular linked list

Step 3: Repeat Step 4 while PTR->NEXT != START Step 4: SET PREPTR = PTR

Step 6: SET PREPTR->NEXT = START Step 7: FREE PTR Step 8: EXIT 1 7 3 4 2 6 5 START, PREPTR, PTR 1 7 3 4 2 6 5 START PTR PREPTR 1 7 3 4 2 6 START

(20)

Algorithm to delete the node after a given node from the circular linked list

Step 1: IF START = NULL, then Write UNDERFLOW Go to Step 9

[END OF IF]

Step 2: SET PTR = START Step 3: SET PREPTR = PTR

Step 4: Repeat Step 5 and 6 while PREPTR->DATA != NUM Step 5: SET PREPTR = PTR

Step 7: SET PREPTR->NEXT = PTR->NEXT Step 8: FREE PTR Step 9: EXIT 1 7 3 4 2 6 5 START, PREPTR, PTR 1 7 3 4 2 6 5 START PREPTR PTR 1 7 3 4 6 5 START

(21)

Doubly Linked List

A doubly linked list or a two way linked list is a more complex type of

linked list which contains a pointer to the next as well as previous node

in the sequence. Therefore, it consists of three parts and not just two.

The three parts are data, a pointer to the next node and a pointer to the

previous node

1

X 1 2 3 4 X

START

In C language, the structure of a doubly linked list is given as,

struct node

{

struct node *prev;

int data;

struct node *next;

};

The prev field of the first node and the next field of the last node will

contain NULL. The prev field is used to store the address of the

preceding node. This would enable to traverse the list in the backward

direction as well.

(22)

Algorithm to insert a new node in the beginning of the doubly linked list

Step 2: SET New_Node = AVAIL Step 3: SET AVAIL = AVAIL->NEXT Step 4: SET New_Node->DATA = VAL Step 5: SET New_Node->PREV = NULL Step 6: SET New_Node->Next = START Step 7: SET START = New_Node

Step 8: EXIT 1 7 3 4 2 X X 9 1 7 3 4 X 2 X START START

(23)

Algorithm to insert a new node at the end of the doubly linked list

Step 2: SET New_Node = AVAIL Step 3: SET AVAIL = AVAIL->NEXT Step 4: SET New_Node->DATA = VAL Step 5: SET New_Node->Next = NULL Step 6: SET PTR = START

Step 7: Repeat Step 8 while PTR->NEXT != NULL Step 8: SET PTR = PTR->NEXT

[END OF LOOP]

Step 9: SET PTR->NEXT = New_Node Step 10: New_Node->PREV = PTR Step 11: EXIT 1 7 3 4 2 X X START, PTR 1 7 3 4 2 X 9 X START PTR

(24)

Step 6: Repeat Step 8 while PTR->DATA != NUM Step 7: SET PTR = PTR->NEXT

[END OF LOOP]

Step 8: New_Node->NEXT = PTR->NEXT Step 9: SET New_Node->PREV = PTR Step 10: SET PTR->NEXT = New_Node Step 11: EXIT 1 7 3 4 2 X X START, PTR 1 7 3 4 2 X X 9 1 7 3 9 4 X 2 X START START PTR

(25)

Algorithm to delete the first node from the doubly linked list

Step 3: SET START = START->NEXT Step 4: SET START->PREV = NULL Step 5: FREE PTR Step 6: EXIT 1 7 3 4 2 X X START, PTR 7 3 4 2 X

(26)

Algorithm to delete the last node of the doubly linked list

Step 3: Repeat Step 4 and 5 while PTR->NEXT != NULL Step 4: SET PTR = PTR->NEXT

[END OF LOOP]

Step 5: SET PTR->PREV->NEXT = NULL Step 6: FREE PTR Step 7: EXIT 1 3 5 7 8 X 9 1 X START, PTR 1 3 5 7 8 X 9 1 X START PTR 1 3 5 7 8 X X START

(27)

Algorithm to delete the node after a given node from the doubly linked list

[END OF LOOP]

Step 5: SET TEMP = PTR->NEXT

Step 6: SET PTR->NEXT = TEMP->NEXT Step 7: SET TEMP->NEXT->PREV = PTR Step 8: FREE TEMP

Step 9: EXIT 1 3 4 7 8 X 9 1 X 1 3 4 7 8 X 9 1 X 1 3 4 8 9 X X START, PTR START PTR START

(28)

Circular Doubly Linked List

• A circular doubly linked list or a circular two way linked list is a more complex type of

linked list which contains a pointer to the next as well as previous node in the

sequence.

• The difference between a doubly linked and a circular doubly linked list is same as that

exists between a singly linked list and a circular linked list. The circular doubly linked list

does not contain NULL in the previous field of the first node and the next field of the

last node. Rather, the next field of the last node stores the address of the first node of

the list, i.e; START. Similarly, the previous field of the first field stores the address of the

last node.

• Since a circular doubly linked list contains three parts in its structure, it calls for more

space per node and for more expensive basic operations. However, it provides the ease

to manipulate the elements of the list as it maintains pointers to nodes in both the

directions . The main advantage of using a circular doubly linked list is that it makes

searches twice as efficient.

1 1 2 3 4

(29)

Algorithm to insert a new node in the beginning of the circular doubly linked list

Step 1: IF AVAIL = NULL, then Write OVERFLOW Go to Step 12 [END OF IF]

Step 2: SET New_Node = AVAIL Step 3: SET AVAIL = AVAIL->NEXT Step 4: SET New_Node->DATA = VAL

Step 6: SET START->PREV->NEXT = new_node; Step 7: SET New_Node->PREV = START->PREV; Step 8: SET START->PREV= new_Node;

Step 9: SET new_node->next = START; Step 10: SET START = New_Node

Step 11: EXIT

1 7 3 4 2

START

9 1 7 3 4 2

(30)

Algorithm to insert a new node at the end of the circular doubly linked list

Step 2: SET New_Node = AVAIL Step 3: SET AVAIL = AVAIL->NEXT Step 4: SET New_Node->DATA = VAL Step 5: SET New_Node->Next = START

Step 6: SET New_Node->PREV = START->PREV Step 7: EXIT

1 7 3 4 2

1 7 3 4 2 9

START START

(31)

[END OF LOOP]

Step 8: New_Node->NEXT = PTR->NEXT Step 9: SET PTR->NEXT->PREV = New_Node Step 9: SET New_Node->PREV = PTR

Step 10: SET PTR->NEXT = New_Node Step 11: EXIT 1 7 3 4 2 START, PTR 1 7 3 4 2 9 START PTR 1 7 3 9 4 2 START

(32)

Algorithm to delete the first node from the circular doubly linked list

Step 3: SET PTR->PREV=>NEXT= PTR->NEXT Step 4: SET PTR->NEXT->PREV = PTR->PREV Step 5: SET START = START->NEXT

Step 6: FREE PTR Step 7: EXIT 1 3 5 7 8 9 1 START, PTR 3 5 7 8 9 1 START

(33)

Algorithm to delete the last node of the circular doubly linked list

Step 2: SET PTR = START->PREV

Step 5: SET PTR->PREV->NEXT = START Step 6: SET START->PREV = PTR->PREV Step 7: FREE PTR Step 8: EXIT 1 3 5 7 8 9 1 START PTR 1 3 5 7 8 X START

(34)

Algorithm to delete the node after a given node from the circular doubly linked list

[END OF LOOP]

Step 5: SET TEMP = PTR->NEXT

Step 6: SET PTR->NEXT = TEMP->NEXT Step 7: SET TEMP->NEXT->PREV = PTR Step 8: FREE TEMP

Step 9: EXIT 1 3 5 7 8 9 1 START 1 3 5 7 8 9 1 START PTR 1 3 4 8 9 START

(35)

Header Linked List

• A header linked list is a special type of linked list which contains a header node at the

beginning of the list. So, in a header linked list START will not point to the first node of

the list but START will contain the address of the header node. There are basically two

variants of a header linked

list-•

Grounded header linked list which stores NULL in the next field of the last node

• Circular header linked list which stores the address of the header node in the next field

of the last node. Here, the header node will denote the end of the list.

1 2 3 4 5 6 X Header Node START 1 2 3 4 5 6 Header Node START

(36)

Algorithm to traverse a Circular Header Linked List

Step 1: SET PTR = START->NEXT

Step 2: Repeat Steps 3 and 4 while PTR != START Step 3: Apply PROCESS to PTR->DATA

Step 5: EXIT

Algorithm to insert a new node after a given node

Step 2: SET New_Node = AVAIL Step 3: SET AVAIL = AVAIL->NEXT Step 4: SET PTR = START->NEXT Step 5: SET New_Node->DATA = VAL

Step 6: Repeat step 4 while PTR->DATA != NUM Step 7: SET PTR = PTR->NEXT

[END OF LOOP]

Step 8: New_Node->NEXT = PTR->NEXT Step 9: SET PTR->NEXT = New_Node Step 10: EXIT

(37)

Push Operation on a Linked Stack

Algorithm to PUSH an element in to a linked stack

Step 1: Allocate memory for the new node and name it as New_Node Step 2: SET New_Node->DATA = VAL

Step 3: IF TOP = NULL, then

SET New_Node->NEXT = NULL SET TOP = New_Node

ELSE

SET New_node->NEXT = TOP SET TOP = New_Node

[END OF IF] Step 4: END 1 7 3 4 2 6 5 X 9 1 7 3 4 2 6 5 X TOP TOP

(38)

Pop Operation on a Linked Stack

Algorithm to POP an element from the stack Step 1: IF TOP = NULL, then

PRINT “UNDERFLOW” [END OF IF]

Step 2: SET PTR = TOP

Step 3: SET TOP = TOP ->NEXT Step 4: FREE PTR Step 5: END 9 1 7 3 4 2 6 5 X TOP 1 7 3 4 2 6 5 X TOP

(39)

Linked Representation of a Queue

• In a linked queue, every element has two parts- one that stores data and the other that

stores the address of the next element. The START pointer of the linked list is used as

FRONT. Here, we will also use another pointer called REAR which will store the address of

the last element in the queue. All insertions will be done at the rear end and all the

deletions are done at the front end. If FRONT = REAR = NULL, then it indicates that the

queue is empty.

• The storage requirement of linked representation of queue with n elements is O(n) and the

typical time requirement for operations is O(1).

1 7 3 4 2 6 5 X FRONT REAR 9 1 7 3 4 2 6 5 X FRONT REAR Insert Operation 1 7 3 4 2 6 5 X REAR FRONT Delete Operation

(40)

Algorithm to insert an element in to a linked queue

Step 1: Allocate memory for the new node and name it as PTR Step 2: SET PTR->DATA = VAL

Step 3: IF FRONT = NULL, then SET FRONT = REAR = PTR;

SET FRONT->NEXT = REAR->NEXT = NULL ELSE

SET REAR->NEXT = PTR SET REAR = PTR

SET REAR->NEXT = NULL [END OF IF]

Step 4: END

Algorithm to delete an element from a linked queue Step 1: IF FRONT = NULL, then

Write “Underflow” Go to Step 3

[END OF IF]

Step 2: SET PTR = FRONT Step 3: FRONT = FRONT->NEXT Step 4: FREE PTR