LINKED LIST

-Dr. Deepika Agrawal

Department of IT,
NIT Raipur
CONCEPTS OF LINKED LIST
A linked list is a collection of data elements called nodes
in which the linear representation is given by links from
one node to the next node.
We are going to discuss different types of linked lists and
the operations that can be performed on these lists.
CONCEPTS OF LINKED LIST
Array:
⚫ Consecutive memory locations
⚫ Specify the size while declaration : Restrict
But what if we are not sure of the number of elements in
advance?
The elements are stored randomly at any location.
Need of DS that removes this restriction:
⚫ Maximum number of elements
⚫ Storage conditions
CONCEPTS OF LINKED LIST
Linked list is a data structure that is free from the
aforementioned restrictions.
A linked list does not store its elements in consecutive
memory locations and the user can add any number of
elements to it.
However, unlike an array, a linked list does not allow
random access of data.
Elements in a linked list can be accessed only in a
sequential manner.
But like an array, insertions and deletions can be done at
any point in the list in a constant time.
CONCEPTS OF LINKED LIST
• 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 contains one or more data
fields and a pointer to the next node.
CONCEPTS OF LINKED LIST
CONCEPTS OF LINKED LIST
A linked list in which every node contains two parts, an
integer and a pointer to the next node.
Left part: Data may include a simple data type, an array,
or a structure.
Right part: A pointer to the next node (or address of the
next node in sequence).
The last node will have no next node connected to it, so
it will store a special value called NULL.
CONCEPTS OF LINKED LIST
Linked lists contain a pointer variable START that stores
the address of the first node in the list.
We can traverse the entire list using START which
contains the address of the first node; the next part of the
first node in turn stores the address of its succeeding
node.
Using this technique, the individual nodes of the list will
form a chain of nodes.
If START = NULL, then the linked list is empty and
contains no nodes.
CONCEPTS OF LINKED LIST
In C, we can implement a linked list using the following
code:
struct node {
int data;
struct node *next;
};
CONCEPTS OF LINKED LIST
Let us see how a linked list is maintained in the memory.
In order to form a linked list, we need a structure called
node which has two fields, DATA and NEXT.
DATA will store the information part and
NEXT will store the address of the next node in
sequence.
CONCEPTS OF LINKED LIST
CONCEPTS OF LINKED LIST
•Two linked lists which are simultaneously maintained in the memory
•Does we encounter any kind of ambiguity?
CONCEPTS OF LINKED LIST
CONCEPTS OF LINKED LIST
If we want to add a node to an already existing linked list
in the memory, we first find free space in the memory
and then use it to store the information.
MEMORY ALLOCATION FOR A LINKED LIST

(a) Students’ linked list and (b) linked list after the insertion of new student’s record
MEMORY ALLOCATION FOR A LINKED LIST
Now, the question is which part of the memory is available
and which part is occupied?
When we delete a node from a linked list, then who changes
the status of the memory occupied by it from occupied to
available?
The answer is the operating system.
We can say that the computer does it on its own without any
intervention from the user or the programmer.
As a programmer, you just have to take care of the code to
perform insertions and deletions in the list.
The computer maintains a list of all free memory cells.
This list of available space is called the free pool.
MEMORY ALLOCATION FOR A LINKED LIST
MEMORY DE-ALLOCATION FOR A LINKED LIST
When we delete a particular node from an existing linked list
or delete the entire linked list, the space occupied by it must
be given back to the free pool so that the memory can be
reused by some other program that needs memory space.
The operating system does this task of adding 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 space.
The operating system scans through all the memory cells and
marks those cells that are being used by some program.
Then it collects all the cells which are not being used and
adds their address to the free pool, so that these cells can be
reused by other programs.
SINGLY LINKED LISTS
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.
A singly linked list allows traversal of data only in one
way.
LINKED LIST OPERATIONS
1. Create a node and linked list
2. Traversal, e.g. display all elements
3. Search node
4. Insert node
at beginning, at end, after/before a node
5. Delete node
at beginning, at end, after/before a node
6. Sort
TRAVERSING A LINKED LIST
Traversing a linked list means accessing the nodes of the
list in order to perform some processing on them.
Remember a linked list always contains a pointer
variable START which stores the address of the first
node of the list.
End of the list is marked by storing NULL or –1 in the
NEXT field of the last node.
For traversing the linked list, we also make use of
another pointer variable PTR which points to the node
that is currently being accessed.
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]
Step 5: EXIT
TRAVERSING A LINKED LIST
Write an algorithm to count the number of nodes in a
linked list.
ALGORITHM
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
Step 5: SET PTR = PTR NEXT
[END OF LOOP]
Step 6: Write COUNT
Step 7: EXIT
SEARCHING FOR A VALUE IN A LINKED LIST
Searching a linked list means to find a particular element
in the linked list.
So searching means finding whether a given value is
present in the information part of the node or not.
If it is present, the algorithm returns the address of the
node that contains the value.
SEARCHING FOR A VALUE IN A LINKED LIST
Step 1: [INITIALIZE] SET PTR = START
Step 2: Repeat Step 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
SEARCHING FOR A VALUE IN A LINKED LIST
INSERTING A NEW NODE IN A LINKED LIST
Case 1: The new node is inserted at the beginning.
Case 2: The new node is inserted at the end.
Case 3: The new node is inserted after a given node.
Case 4: The new node is inserted before a given node.
INSERTING A NEW NODE IN A LINKED LIST
Overflow
⚫ Overflow is a condition that occurs when AVAIL = NULL or
no free memory cell is present in the system.
⚫ When this condition occurs, the program must give an
appropriate message.
INSERTING A NODE AT THE BEGINNING OF A LINKED
LIST
Suppose we want to add a new node with data 9 and add
it as the first node of the list.
Then the following changes will be done in the linked
list.
INSERTING A NODE AT THE BEGINNING OF A LINKED
LIST
Step 1: IF AVAIL = NULL
⚫ 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
INSERTING A NODE AT THE END OF A LINKED LIST
Suppose we want to add a new node with data 9 as the
last node of the list.
Then the following changes will be done in the linked
list.
INSERTING A NODE AT THE END OF A LINKED LIST
INSERTING A NODE AT THE END OF A LINKED LIST
Step 1: IF AVAIL = NULL
⚫ Write OVERFLOW
⚫ Go to Step 1
[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 = 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
INSERTING A NODE AFTER A GIVEN NODE IN A
LINKED LIST
Suppose we want to add a new node with value 9 after
the node containing data 3.
Before discussing the changes that will be done in the
linked list.
INSERTING A NODE AFTER A GIVEN NODE IN A
LINKED LIST
INSERTING A NODE AFTER A GIVEN NODE IN A
LINKED LIST
Step 1: IF AVAIL = NULL
⚫ 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 Steps 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
INSERTING A NODE BEFORE A GIVEN NODE IN A
LINKED LIST
Suppose we want to add a new node with value 9 before
the node containing 3.
INSERTING A NODE BEFORE A GIVEN NODE IN A
LINKED LIST
INSERTING A NODE BEFORE A GIVEN NODE IN A
LINKED LIST
Step 1: IF AVAIL = NULL
⚫ 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 Steps 8 and 9 while PTR 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
DELETING A NODE FROM A LINKED LIST
Case 1: The first node is deleted.
Case 2: The last node is deleted.
Case 3: The node after a given node is deleted.
DELETING A NODE FROM A LINKED LIST
Underflow:
⚫ Underflow is a condition that occurs when we try to delete a
node from a linked list that is empty.
⚫ This happens when START = NULL or when there are no
more nodes to delete.
⚫ Note that when we delete a node from a linked list, we
actually have to free the memory occupied by that node.
⚫ The memory is returned to the free pool so that it can be used
to store other programs and data.
⚫ Whatever be the case of deletion, we always change the
AVAIL pointer so that it points to the address that has been
recently vacated.
DELETING THE FIRST NODE FROM A LINKED LIST
When we want to delete a node from the beginning of the
list, then the following changes will be done in the linked
list.
DELETING A NODE FROM A LINKED LIST
Step 1: IF START = NULL
⚫ 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
DELETING THE LAST NODE FROM A LINKED LIST
Suppose we want to delete the last node from the linked
list, then the following changes will be done in the linked
list.
DELETING THE LAST NODE FROM A LINKED LIST
DELETING THE LAST NODE FROM A LINKED LIST
Step 1: IF START = NULL
⚫ Write UNDERFLOW
⚫ Go to Step 8
[END OF IF]
Step 2: SET PTR = START
Step 3: Repeat Steps 4 and 5 while PTR NEXT != NULL
Step 4: SET PREPTR = PTR
Step 5: SET PTR = PTR NEXT
[END OF LOOP]
Step 6: SET PREPTR NEXT = NULL
Step 7: FREE PTR
Step 8: EXIT
DELETING THE NODE AFTER A GIVEN NODE IN A
LINKED LIST
Suppose we want to delete the node that succeeds the
node which contains data value 4.
Then the following changes will be done in the linked
list.
DELETING THE NODE AFTER A GIVEN NODE IN A
LINKED LIST
DELETING THE NODE AFTER A GIVEN NODE IN A
LINKED LIST
Step 1: IF START = NULL
⚫ Write UNDERFLOW
⚫ Go to Step 10
[END OF IF]
Step 2: SET PTR = START
Step 3: SET PREPTR = PTR
Step 4: Repeat Steps 5 and 6 while PREPTR DATA != NUM
Step 5: SET PREPTR = PTR
Step 6: SET PTR = PTR NEXT
[END OF LOOP]
Step 7: SET TEMP = PTR
Step 8: SET PREPTR NEXT = PTR NEXT
Step 9: FREE TEMP
Step 10 : EXIT
PROGRAM
Write a program to create a linked list and perform
insertions and deletions of all cases. Write functions to
sort and finally delete the entire list at once.
CIRCULAR LINKED LISTS
In a circular linked list, the last node contains a pointer to
the first node of the 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
started.
Thus, a circular linked list has no beginning and no
ending.
The only downside of a circular linked list is the
complexity of iteration.
Note that there are no NULL values in the NEXT part of
any of the nodes of list.
CIRCULAR LINKED LISTS
We can traverse the list until we find the NEXT entry
that contains the address of the first node of the list.
This denotes the end of the linked list, that is, the node
that contains the address of the first node is actually the
last node of the list.
CIRCULAR LINKED LISTS
CIRCULAR LINKED LISTS
INSERTING A NEW NODE IN A CIRCULAR LINKED
LIST
Case 1: The new node is inserted at the beginning of the
circular linked list.
Case 2: The new node is inserted at the end of the
circular linked list.
INSERTING A NODE AT THE BEGINNING OF A
CIRCULAR LINKED LIST
Suppose we want to add a new node with data 9 as the
first node of the list.
Then the following changes will be done in the linked
list.
ALGORITHM
Step 1: IF AVAIL = NULL
Write OVERFLOW
Go to Step 11
[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: Repeat Step 7 while PTR NEXT != START
Step 7: PTR = PTR NEXT
[END OF LOOP]
Step 8: SET NEW_NODE NEXT = START
Step 9: SET PTR NEXT = NEW_NODE
Step 10 : SET START = NEW_NODE
Step 11: EXIT
INSERTING A NODE AT THE END OF A CIRCULAR
LINKED LIST
Suppose we want to add a new node with data 9 as the
last node of the list.
Then the following changes will be done in the linked
list.
ALGORITHM
Step 1: IF AVAIL = NULL
Write OVERFLOW
Go to Step 1
[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 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
DELETING A NODE FROM A CIRCULAR LINKED LIST
Case 1: The first node is deleted.
Case 2: The last node is deleted.
DELETING THE FIRST NODE FROM A CIRCULAR
LINKED LIST
When we want to delete a node from the beginning of the
list, then the following changes will be done in the linked
list.
ALGORITHM
Step 1: IF START = NULL
Write UNDERFLOW
Go to Step 8
[END OF IF]
Step 2: SET PTR = START
Step 3: Repeat Step 4 while PTR NEXT != START
Step 4: SET PTR = PTR NEXT
[END OF LOOP]
Step 5: SET PTR NEXT = START NEXT
Step 6: FREE START
Step 7: SET START = PTR NEXT
Step 8: EXIT
DELETING THE LAST NODE FROM A CIRCULAR
LINKED LIST
Suppose we want to delete the last node from the linked
list, then the following changes will be done in the linked
list.
DELETING THE LAST NODE FROM A CIRCULAR
LINKED LIST
ALGORITHM
Step 1: IF START = NULL
Write UNDERFLOW
Go to Step 8
[END OF IF]
Step 2: SET PTR = START
Step 3: Repeat Steps 4 and 5 while PTR NEXT != START
Step 4: SET PREPTR = PTR
Step 5: SET PTR = PTR NEXT
[END OF LOOP]
Step 6: SET PREPTR NEXT = START
Step 7: FREE PTR
Step 8: EXIT
DOUBLY LINKED LISTS
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 the previous node in the sequence.
Therefore, it consists of three parts—data, a pointer to
the next node, and a pointer to the previous node.
DOUBLY LINKED LISTS
In C, the structure of a doubly linked list can be 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, which enables us to traverse the list in the backward
direction
DOUBLY LINKED LISTS
A doubly linked list calls for more space per node and
more expensive basic operations.
However, a doubly linked list provides the ease to
manipulate the elements of the list as it maintains
pointers to nodes in both the directions (forward and
backward).
The main advantage of using a doubly linked list is that it
makes searching twice as efficient.
DOUBLY LINKED LISTS
INSERTING A NEW NODE IN A DOUBLY LINKED LIST
Case 1: The new node is inserted at the beginning.
Case 2: The new node is inserted at the end.
Case 3: The new node is inserted after a given node.
Case 4: The new node is inserted before a given node
INSERTING A NODE AT THE BEGINNING OF A
DOUBLY LINKED LIST
Suppose we want to add a new node with data 9 as the
first node of the list.
Then the following changes will be done in the linked
list.
ALGORITHM
Step 1: IF AVAIL = NULL
Write OVERFLOW
Go to Step 9
[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 PREV = NULL
Step 6: SET NEW_NODE NEXT = START
Step 7: SET START PREV = NEW_NODE
Step 8: SET START = NEW_NODE
Step 9: EXIT
INSERTING A NODE AT THE END OF A DOUBLY
LINKED LIST
Suppose we want to add a new node with data 9 as the
last node of the list. Then the following changes will be
done in the linked list.
ALGORITHM
Step 1: IF AVAIL = NULL
Write OVERFLOW
Go to Step 11
[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= 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 : SET NEW_NODE PREV = PTR
Step 11: EXIT
INSERTING A NODE AFTER A GIVEN NODE IN A
DOUBLY LINKED LIST
Suppose we want to add a new node with value 9 after
the node containing 3.
ALGORITHM
Step 1: IF AVAIL = NULL
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: Repeat Step 7 while PTR DATA != NUM
Step 7: SET PTR = PTR NEXT
[END OF LOOP]
Step 8: SET NEW_NODE NEXT = PTR NEXT
Step 9: SET NEW_NODE PREV = PTR
Step 10 : SET PTR NEXT = NEW_NODE
Step 11: SET PTR NEXT PREV= NEW_NODE
Step 12: EXIT
INSERTING A NODE BEFORE A GIVEN NODE IN A
DOUBLY LINKED LIST
Suppose we want to add a new node with value 9 before
the node containing 3.
ALGORITHM
Step 1: IF AVAIL = NULL
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: Repeat Step 7 while PTR DATA != NUM
Step 7: SET PTR = PTR NEXT
[END OF LOOP]
Step 8: SET NEW_NODE NEXT = PTR
Step 9: SET NEW_NODE PREV = PTR PREV
Step 10:SET PTR PREV = NEW_NODE
Step 11:SET PTR PREV NEXT=NEW_NODE
Step 12: EXIT
DELETING A NODE FROM A DOUBLY LINKED LIST
Case 1: The first node is deleted.
Case 2: The last node is deleted.
Case 3: The node after a given node is deleted.
Case 4: The node before a given node is deleted.
DELETING THE FIRST NODE FROM A DOUBLY
LINKED LIST
When we want to delete a node from the beginning of the
list, then the following changes will be done in the linked
list.
ALGORITHM
Step 1: IF START = NULL
Write UNDERFLOW
Go to Step 6
[END OF IF]
Step 2: SET PTR = START
Step 3: SET START = START NEXT
Step 4: SET START PREV = NULL
Step 5: FREE PTR
Step 6: EXIT
DELETING THE LAST NODE FROM A DOUBLY
LINKED LIST
Suppose we want to delete the last node from the linked
list, then the following changes will be done in the linked
list
ALGORITHM
Step 1: IF START = NULL
Write UNDERFLOW
Go to Step 7
[END OF IF]
Step 2: SET PTR = START
Step 3: Repeat Step 4 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
DELETING THE NODE AFTER A GIVEN NODE IN A
DOUBLY LINKED LIST
Suppose we want to delete the node that succeeds the
node which contains data value 4. Then the following
changes will be done in the linked list.
ALGORITHM
Step 1: IF START = NULL
Write UNDERFLOW
Go to Step 9
[END OF IF]
Step 2: SET PTR = START
Step 3: Repeat Step 4 while PTR DATA != NUM
Step 4: SET PTR = PTR NEXT
[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
DELETING THE NODE BEFORE A GIVEN NODE IN A
DOUBLY LINKED LIST
Suppose we want to delete the node preceding the node
with value 4.
ALGORITHM
Step 1: IF START = NULL
Write UNDERFLOW
Go to Step 9
[END OF IF]
Step 2: SET PTR = START
Step 3: Repeat Step 4 while PTR DATA != NUM
Step 4: SET PTR = PTR NEXT
[END OF LOOP]
Step 5: SET TEMP = PTR PREV
Step 6: SET TEMP PREV NEXT = PTR
Step 7: SET PTR PREV = TEMP PREV
Step 8: FREE TEMP
Step 9: EXIT