Unit-2

Linear Data Structures

List ADT
 Syllabus

• Arrays • Circular Linked List

• Operations on Arrays-Insertion and Deletion • Circular Linked List-Implementation
• Applications on Array
• Applications of Circular List -Joseph
• Multidimensional Arrays- Sparse Matrix
Problem
• Linked List Implementation – Insertion,
• Doubly Linked List
Deletion and Search
• Applications of Linked List
• Doubly Linked List –Insertion

• Polynomial Arithmetic • Doubly Linked List Insertion variations

• Cursor Based Implementation • Doubly Linked List –Deletion
• Cursor Based Implementation – Methodology • Doubly Linked List - Search
Arrays
Data Structure-Introduction
Data Structure-Introduction
• DS is classified into
• Linear DS
• Data elements are arranged sequentially or linearly
• Single level is involved. Therefore, we can traverse all the elements in single run only.
• Easy to implement because computer memory is arranged in a linear way.
• Examples are Array, Stack, Queue, Linked List.

• Nonlinear DS
• Data elements are not arranged sequentially or linearly
• Single level is not involved. Therefore, we can’t traverse all the elements in single run
only.
• Not easy to implement in comparison to linear data structure. It utilizes computer
memory efficiently in comparison to a linear data structure.
• Examples are Trees and Graphs  
Linear Vs Nonlinear Data Structures
S.No Linear Nonlinear
1 Data elements are arranged in a linear Data elements are attached in hierarchically
order where each and every elements are manner.
attached to its previous and next adjacent.
2 Single level is involved.  Multiple levels are involved.
3 Its implementation is easy Its implementation is complex
4 Data elements can be traversed in a single Data elements can’t be traversed in a single run
run only. only.
5 Memory is not utilized in an efficient way. Memory is utilized in an efficient way. 
6 Examples are: array, stack, queue, linked Examples are: trees and graphs.
list, etc.
7 Applications of linear data structures are Applications of non-linear data structures are in
mainly in application software Artificial Intelligence and image processing.
development.
8 Time complexity often increases with increase Time complexity often remain with increase in size.
in size.
Linear Data Structure-Array

• An array is a collection of items stored at contiguous memory

locations.
• The idea is to store multiple items of the same type together.
• This makes it easier to calculate the position of each element by
simply adding an offset to a base value, i.e., the memory location of
the first element of the array
Array… • List of a finite number n of homogeneous data elements , such that
• Elements are referenced by an index
• Elements are stored in successive memory locations.
Array…
Linear Structure-Operations: Array ADT
❖Traversal : Processing each element in the list
❖Search : Finding the location of the element with a given
value (key)
❖Insertion : Adding a new element to the list
❖Deletion : Removing an element from the list
❖Sorting : Arranging the elements in some type of order
❖Merging : Combining two lists into a single list
Linear Arrays…

• Number of elements in a array is called as length of the array

• Elements of an array A is denoted by subscript notation or

• A1, A2, A3, …, An

• By bracket notation

• A[1], A[2], A[3], …, A[N]

• A[1] is called as subscript or index

Linear Arrays…

• Array can be processed using a loop

• Each programming language has its own rules for declaring arrays
• Declaration can be given implicitly or explicitly with 3 items of
information
• 1) Name of the array
• 2) Data type of the array
• 3) Index set of the array
Types of indexing in an array 

• 0 (zero-based indexing): The first element of the array is indexed by a

subscript of 0.
• 1 (one-based indexing): The first element of the array is indexed by the
subscript of 1.
• n (n-based indexing): The base index of an array can be freely chosen.
Programming languages allowing n-based indexing also allow negative
index values, and other scalar data types like enumerations, or characters
may be used as an array index.
Linear Array…

• Some Programming languages(FORTRAN and PASCAL) allocate

memory space for arrays statically, during program compilation;
hence size of the array is fixed during program execution

• Some programming languages(C,C++) allow one to read an integer n

and then declare an array with n elements; said to allocate memory
dynamically.
Arrays as ADT

• Array is a fundamental ADT

• Eg. Object(A,N). An array A is created with set of N elements in it
• A[i] is an item in the array A stored in its ith position
• Arrays are named as A[1], A[2],…., A[N]
• In computers, data is mostly stored in the form of arrays.
Representation of Linear Arrays in Memory
Representation of Linear Arrays in Memory…

• A is Linear Array
• 1, 2, 3, 4 are index values
• 1000 is bases address(starting address of the array) in bytes
• 10, 100, 20, 500, 600 are elements of the array
Operations on arrays

• Array traversal
• Insertion
• Deletion
• Sorting
• Searching
Array Traversal -Eg
#include <stdio.h>
main()
{
int Array[] = {1,3,5,7,8};
int item = 10, k = 3, n = 5;
Output:
int i = 0, j = n;
The original array elements are :
printf("The original array elements are :\n"); Array[0] = 1
for(i = 0; i<n; i++) Array[1] = 3
{ Array[2] = 5
printf("Array[%d] = %d \n", i, Array[i]); Array[3] = 7
Array[4] = 8
}
}
Insertion
• Insertion refers to addition of element to the array
• A new element can be added at the beginning, end, or any given index
of array.
• Inserting an element at the end of the array can be easily done
provided memory space allocated is large enough to accommodate the
element.
• Inserting an element in the middle of the array is somewhat difficult
• Half of the element is must be moved downward to new loactions
to accommodate the new element to keep the order of other
elements.
Insertion…
#include <stdio.h>
main()
{
int LA[] = {1,3,5,7,8};
int item = 10, k = 3, n = 5;
OUTPUT:
int i = 0, j = n;
printf("The original array elements are :\n"); The original array elements are :
LA[0] = 1
for(i = 0; i<n; i++) LA[1] = 3
LA[2] = 5
printf("LA[%d] = %d \n", i, LA[i]); LA[3] = 7
n = n + 1; LA[4] = 8
The array elements after insertion :
while( j >= k) LA[0] = 1
{ LA[j+1] = LA[j]; j = j - 1; } LA[1] = 3
LA[2] = 5
LA[k] = item; LA[3] = 10
LA[4] = 7
printf("The array elements after insertion :\n"); LA[5] = 8
for(i = 0; i<n; i++)
printf("LA[%d] = %d \n", i, LA[i]); }
Insertion…
Deletion

• Deletion refers to removing element from the array

• Deleting an element at the end of the array presents no difficulties but
deleting an element in the middle requires that each subsequent
element be moved one location upward
Deletion…
#include <stdio.h>
void main()
{
int LA[] = {1,3,5,7,8};
int k = 3, n = 5; Output:
int i, j;
The original array elements are :
printf("The original array elements are :\n");
LA[0] = 1
for(i = 0; i<n; i++) LA[1] = 3
printf("LA[%d] = %d \n", i, LA[i]); LA[2] = 5
j = k; LA[3] = 7
while( j < n) LA[4] = 8
{ LA[j-1] = LA[j]; j = j + 1; } The array elements after deletion :
LA[0] = 1
n = n -1;
LA[1] = 3
printf("The array elements after deletion :\n"); LA[2] = 7
for(i = 0; i<n; i++) LA[3] = 8
printf("LA[%d] = %d \n", i, LA[i]);
}
Deletion…
 Searching
⮚Search for an array element based on its value or its index.

Algorithm
1.Start
2.Set j=0
3.Repeat steps 4 and 5 while J<N
4.If LA[J] is equal to item then goto step 6
5.Set J=J+1
6.Print J, item
7.Stop
Searching…

#include <stdio.h>
void main()
{
int LA[] = {1,3,5,7,8};
int item = 5, n = 5;
int i = 0, j = 0; Output:
printf("The original array elements are :\n"); The original array elements are
for(i = 0; i<n; i++) LA[0] = 1
printf("LA[%d] = %d \n", i, LA[i]); LA[1] = 3
while( j < n) LA[2] = 5
{ LA[3] = 7
if( LA[j] == item )
LA[4] = 8
break;
Found element 5 at position 3
j = j + 1;
}
printf("Found element %d at position %d\n", item, j+1);
}
Applications of arrays
 Applications

● Arrays are used to Store List of values ● Arrays are used to implement Sorting Algorithms
In c programming language, single dimensional arrays are
We use single dimensional arrays to implement sorting
used to store list of values of same datatype. In other algorihtms like ...
words, single dimensional arrays are used to store a row
a. Insertion Sort
of values. In single dimensional array data is stored in
linear form. b. Bubble Sort
● Arrays are used to Perform Matrix Operations c. Selection Sort
We use two dimensional arrays to create matrix. We can d. Quick Sort
perform various operations on matrices using two e. Merge Sort, etc.,
dimensional arrays. ● Arrays are used to implement Datastructures
● Arrays are used to implement Search Algorithms We use single dimensional arrays to implement
We use single dimensional arrays to implement search datastructures like...
algorihtms like ... f. Stack Using Arrays
1. Linear Search
g. Queue Using Arrays
2. Binary Search
● Arrays are also used to implement CPU Scheduling
Algorithms
Multidimensional Arrays

• Dynamically allocating a 2-d Array

• Malloc() can be used to allocate a block of memory which can
simulate an array.
• Similarly we can do the same to simulate multidimensional arrays.
• If we are not sure of the number of columns that the array will have,
then we will first allocate memory for each row by calling malloc.
• Each row will then be represented by a pointer.
Multidimensional Arrays…

Example

#include #include <stdio.h

int main()
{ int **arr, i, j, ROWS, COLS;
printf("\n Enter the number of rows and columns in the array: ");
scanf("%d %d",ROWS,COLS);
arr = (int **)malloc(ROWS * sizeof(int *));
if(arr == NULL)
{
printf("\n Memory could not be allocated");
exit(-1);
}
Multidimensional Arrays…

for(i=0; i< ROWS; i++)

for(j = 0; j < COLS; j++)
scanf("%d",&arr[i][j]);
printf("\n The array is as follows: ");
for(i = 0; i < ROWS; i++)
for(j = 0; j < COLS; j++)
printf("%d",arr[i][j]);
for(i = 0; i < ROWS; i++)
free(arr[i]);
free(arr);
return 0;
}
Sparse Matrix
Sparse Matrix…

• The 2d array can be used to represent a sparse matrix in which there are three
rows named as:
• Row: It is an index of a row where a non-zero element is located.
• Column: It is an index of the column where a non-zero element is located.
• Value: The value of the non-zero ele
• Representing a sparse matrix by a 2D array leads to wastage of lots of memory
as zeroes in the matrix are of no use in most of the cases.
• So, instead of storing zeroes with non-zero elements, we only store non-zero
elements. T
• This means storing non-zero elements with triples- (Row, Column, value).
Sparse Matrix…

• Harry Markowitz coined the term Sparse Matrix

• Sparse matrices can be useful for computing large-scale
applications that dense matrices cannot handle.
• One such application involves solving partial differential
equations by using the finite element method.
Sparse matrix…
Sparse matrix…
Sparse Matrix Representation
Sparse Matrix Representation…
Sparse Matrix Representation…
Sparse Matrix Representation…
Sparse Matrix Representation…
Sparse Matrix Representation…
Sparse Matrix Representation…
Sparse Matrix Example
Matrix Transposition
Matrix Transposition…
Matrix Multiplication
Matrix Multiplication…
Multiplication of Two Sparse Matrices
Multiplication of Two Sparse Matrices…
Multiplication of Two Sparse Matrices…
Multiplication of Two Sparse Matrices…
Linked List

105
Introduction
• Linked List is a linear data structure.
• A list can be defined as an ordered collection
• A node contains two fields i.e. data stored at that
particular address and the pointer which contains
the address of the next node in the memory.
• The last node of the list contains pointer to the null.

106
• A linked list can change during execution.
• Successive elements are connected by pointers.
• Last element points to NULL.
• It can grow or shrink in size during execution of a program.
• It can be made just as long as required.
• It does not waste memory space.

107
Basic operations of Linked List
• Creation- Creates a linked list
• Insertion − Adds an element to the list.
• Deletion − Deletes an element to the list.
• Display − Displays the complete list.
• Search − Searches an element using the given key.
• Delete − Deletes an element using the given key.

108
Creating a Linked List

109
• To start with, we have to create a node (the first node), and make head
point to it.
• struct node   
• {  
•     int data;   
•     struct node *next;  
• };  
• struct node *head, *ptr;   
• ptr = (struct node *)malloc(sizeof(struct node *));  

head
roll next
name
age

110
Contd.
• If there are n number of nodes in the initial linked list:
• Allocate n records, one by one.
• Read in the fields of the records.
• Modify the links of the records so that the chain is formed.

head

A B C

111
Inserting a Node in a List

112
• The insertion into a singly linked list can be performed
at different positions. Based on the position of the
new node being inserted, the insertion is categorized
into the following categories.

113
Illustration: Insertion
A B C

Item to be
tmp X inserted

A B C

curr
X

114
Pseudo-code for insertion
typedef struct nd {
struct item data;
struct nd * next;
} node;

void insert(node *curr)

{
node * tmp;

tmp=(node *) malloc(sizeof(node));
tmp->next=curr->next;
curr->next=tmp;
}
115
Contd.
• When a node is added at the beginning,
– Only one next pointer needs to be modified.
• head is made to point to the new node.
• New node points to the previously first element.
• When a node is added at the end,
– Two next pointers need to be modified.
• Last node now points to the new node.
• New node points to NULL.
• When a node is added in the middle,
– Two next pointers need to be modified.
• Previous node now points to the new node.
• New node points to the next node.

116
Deleting a node from the
list

117
The Deletion of a node from a singly linked list can be performed
at different positions. Based on the position of the node being
deleted, the operation is categorized into the following
categories.

118
Illustration: Deletion
Item to be deleted

A B C

tmp
curr

A B C

119
Pseudo-code for deletion
typedef struct nd {
struct item data;
struct nd * next;
} node;

void delete(node *curr)

{
node * tmp;
tmp=curr->next;
curr->next=tmp->next;
free(tmp);
}

120
Application of Linked List

121
Applications of linked list in computer
science 
• Implementation of stacks and queues
• Implementation of graphs : Adjacency list representation of graphs is
most popular which is uses linked list to store adjacent vertices.
• Dynamic memory allocation : We use linked list of free blocks.
• Maintaining directory of names
• Performing arithmetic operations on long integers
• Manipulation of polynomials by storing constants in the node of
linked list
• representing sparse matrices
122
Applications of linked list in real world
• Image viewer – Previous and next images are linked, hence can be
accessed by next and previous button.
• Previous and next page in web browser – We can access previous and
next url searched in web browser by pressing back and next button
since, they are linked as linked list.
• Music Player – Songs in music player are linked to previous and next
song. you can play songs either from starting or ending of the list.

123
Stack Implementations: Using Array and Linked List

124
Stack: Linked List Structure

PUSH OPERATION

top

125
Stack: Linked List Structure

POP OPERATION

top

126
Basic Idea
• In the linked list implementation, we would:
• Maintain the stack as a linked list.
• A pointer variable top points to the start of the list.
• The first element of the linked list is considered as the stack top.

128
Declaration
struct lifo
{
int value;
struct lifo *next;
};
typedef struct lifo
stack;

stack *top;

129
Stack Creation
void create (stack **top)
{
*top = NULL;

/* top points to NULL,

indicating empty
stack */
}

130
Pushing an element into the stack
void push (stack **top, int element)
{
stack *new;
new = (stack *) malloc(sizeof(stack));
if (new == NULL)
{
printf (“\n Stack is full”);
exit(-1);
}
new->value = element;
new->next = *top;
*top = new;
}
ARRAY

131
Popping an element
int pop (stack **top)
from the stack
{
int t;
stack *p;
if (*top == NULL)
{
printf (“\n Stack is empty”);
exit(-1);
}
else
{
t = (*top)->value;
p = *top;
*top = (*top)->next;
free (p);
return t;
}
} ARRAY

132
Polynomial Arithmetic using Linked List

133
• A polynomial p(x) is the expression in variable x which
is in the form (axn + bxn-1 + …. + jx+ k), where a, b, c ….,
k fall in the category of real numbers and 'n' is non
negative integer, which is called the degree of
polynomial.
• A polynomial can be thought of as an ordered list of
non zero terms. Each non zero term is a two-tuple
which holds two pieces of information:
• The exponent part
• The coefficient part

134
Adding two polynomials using Linked List
Given two polynomial numbers represented by a linked list.
Write a function that add these lists means add the coefficients
who have same variable powers.

1st number = 5x2 + 4x1 + 2x0

2nd number = -5x1 + 5x0

135
Cursor Based Implementation
Methodology
Motivation
• Some programming languages doesn’t support pointers.
• But we need linked list representation to store data.
• Solution:
• Cursor implementation – Linked list implementation using arrays.
What is Cursor List?
• A CursorList is an array version of a Linked List.
• It is an array of list nodes but instead of each node containing a
pointer to the next item in the linked list, each node element in the
array contains the index for the next node element.
Methodology
• Convert a linked list based implementation to an array based
implementation. 
• Instead of pointers, array index could be used to keep track of node.
• Convert the node structures (collection of data and next pointer) to a
global array of structures.
• Need to find a way to perform dynamic memory allocation performed
using malloc and free functions.
 Methodology: 1. Cursor Representation Model
Slot Element Next Cursor Model:
0 header 1
• Global array of structures
1 - 2 • Each structure has two members
2 - 3 1. Element
3 - 4 2. Next
• Figure 2.7.1 has 11 array of structures.
4 - 5
5 - 6
Initial configuration of cursor:
6 - 7
7 - 8 • It contains empty list with 0 as header.
8 - 9
• 0🡪1🡪2🡪3🡪4🡪5🡪6🡪7🡪8🡪9🡪10
9 - 10
10 - 0 • Node 10 is the last node of the list with next pointer to ‘ 0 ’.

Figure 2.7.1 Array representation of the linked list

Inserting an element in the linked list
• Steps:
1. Allocate a node from the cursor model.
2. Place the value in the element field of the node
3. Adjust the next pointer.
 Methodology: 1. Insert an element in a list
Slot Element Next 1. To Allocate a node to store an element Slot Element Next
• Find the free space in the cursor
0 header 1 0 header 3
• Select the node pointed by the next field of
1 - 3 the 0th node. 1 10 0
• In the figure 2.7.2 0 🡪 next is 1
2 header 0 2 header 1
• Find the location of node in the list after
3 - 4 which the new element to be inserted 3 - 4
4 - 5 4 - 5
2. Place the element in the node
5 - 6 • 1🡪element = 10 5 - 6
6 - 8 6 - 8
3. Adjust the pointers
7 header 0 7 header 0
• 0🡪next=1🡪next
8 - 9 • 1🡪next=0 8 - 9
9 - 10 • 2🡪next=1
9 - 10
10 - 0
Updated List is 2🡪1 10 - 0
Figure 2.7.2 Initial Configuration
After inserting 20 and 30
Slot Element Next Slot Element Next Slot Element Next
0 header 3 0 header 4 0 header 5
1 10 0 1 10 3 1 10 3
2 header 1 2 header 1 2 header 1
3 - 4 Insert(20,L) 3 20 0 Insert(30,L) 3 20 4
4 - 5 4 - 5 4 30 0
5 - 6 5 - 6 5 - 6
6 - 8 6 - 8 6 - 8
7 header 0 7 header 0 7 header 0
8 - 9 8 - 9 8 - 9
9 - 10 9 - 10 9 - 10
10 - 0 10 - 0 10 - 0
Methodology: 2. Finding an element from the list
• Start from the header of the list.
• Traverse the list by comparing the elements in each node
• (p🡪element == x)
• If matching element is found return the slot number else return not
found.
Methodology: 2. Finding an element from the list
Slot Element Next Element
Slot Next
0 header 5 0 header 5
1 10 3 1 10 No match
3
2 header 1 2 header 1
find(20,L)
3 20 4 3 20 match 4
4 30 0 4 30 0 Returns 3
5 - 6 5 - 6
6 - 8 6 - 8
7 header 0 7 header 0
8 - 9
8 - 9
9 - 10
9 - 10
10 - 0
10 - 0
Methodology: 2. Delete an element from a list
• Find the address of the element to be deleted.
• Get the address of the previous element(p) of the deletion element(q)
• Adjust the next element of the previous node.
• p🡪next = q🡪next
• Add the freed node to the empty list
• q🡪next=0🡪next
• 0🡪next = q
Methodology: 2. Deleting a node from the list
Slot Element Next Slot Element Next
0 header 5 0 header 3
1 10 3 1 10 4
2 header 1 2 header 1
3 20 4 Delet(20,L) 3 - 5
4 30 0 4 30 0
5 - 6 5 - 6
6 - 8 6 - 8
7 header 0 7 header 0
8 - 9 8 - 9
9 - 10 9 - 10
10 - 0 10 - 0
Cursor Based Implementation
1. Convert the node structures (collection of data and next
pointer) to a global array of structures.

Declarations for cursor implementation of linked lists

Struct Node inde Element Next

{ x
ElementType Element;
Position Next; 0 20 4
};

struct Node CursorSpace[SpaceSize];

typedef NodePtr List;
typedef NodePtr Position;
2. Need to find a way to perform dynamic memory allocation performed using malloc and free
functions.

CursorAlloc() CursorFree()

Position CursorAlloc( void ) void CursorFree( Position P)

{ {
Position P;
CursorSpace[P].Next=CursorSpace[0].Next;
CursorSpace[0].Next = P;
P = CursorSpace[0].Next;
CursorSpace[0].Next = CursorSpace[P].Next; }

return P;
}
Initializing Cursor Space
• Cursor_space[list] =0;
Cursor implementation of linked lists - Example

“-” in Element column represents empty cell.

“0” in Next column represents end of the list.

• If L= 5, then L represents list (A, B, E)

• If M= 3, then M represents list (C, D, F)
• Empty list(Always starts from 0): 0🡪6🡪4
IsEmpty() and IsLast() Slot Element Next
0 header 5

/* Return true if L is empty */ 1 10 3

int IsEmpty(List L) 2 header 1
{ 3 20 4
return CursorSpace[L].Next == 0; 4 30 0
} 5 - 6
6 - 8
/* Return true if P is the last node in the linked list */ 7 header 0
/* Parameter L is unused in this implementation */
8 - 9
9 - 10
int IsLast(Position P, List L)
10 - 0
{
return CursorSpace[P].Next == 0;
}
Insert Routine
/* Insert (after legal position P) */
/* Header implementation assumed */
/* Parameter L is unused in this implementation */

void Insert( ElementType x, List L, Position P )

{
Position TmpCell;

TmpCell = CursorAlloc( )
if( TmpCell ==0 )
fatal_error("Out of space!!!");

CursorSpace[TmpCell].Element = x;
CursorSpace[TmpCell]. Next = CursorSpace[P]. Next;
CursorSpace[P]. Next =TmpCell;
}
Find Routine
/* Return Position of X in L; 0 if not found */
/* Uses a header node */

Position Find( ElementType x, List L)

{
Position P;

P = CursorSpace[L].Next;
while( P && CursorSpace[P].Element != x )
P = CursorSpace[P].Next;

return P;
}
Deletion Routine
/* Delete first occurrence of x from a list */
/* Assume use of a header node */

void Delete( ElementType x, List L )

{
Position P, TmpCell;

P = FindPrevious( x, L );

if( !IsLast( P, L) ) /* x is found; delete it */

{
TmpCell = CursorSpace[P].Next;
CursorSpace[P].Next = CursorSpace[TmpCell].Next;
CursorFree( TmpCell );
}
}
Practice Exercises
1. Find the 3rd node from the end of a linked list Slot Element Next
given in the following cursor representation. 0 header 6
1 24 3
2. Sort the element of the linked list . 2 21 1
3. Find the 1st largest element in the linked list. 3 12 4

4. Find the first 3 smallest element from the 4 5 9

5 7 0
linked list.
6 - 8
5. Remove duplicates from the given linked list. 7 header 2
8 - 10
9 15 5
10 - 0
 Review Questions
1. Why we need cursor implementation? Implement linked list in programming language that do not support pointers
2. The cursor implementation is ________________. Linked list implementation using arrays.
3. How to create linked list using cursor implementation? Global Arrays of structures
4. Default list in cursor implementation is called ___________. Free list
5. The header of the free list is at location__________. 0
Value at next field of 0
6. Node to allocate and released node always occur at ________.
7. Condition to find the last node of the list___________. if(cursor[p].next == 0)

8. Condition to check whether the list is empty or not___________. if(cursor[L].next == 0)

9. Code to assign element to the node ____________. cursor[p].Element = x
10. Code to set a node as last node of a list ______________________. cursor[p].next = 0
ARRAYS AND LISTS
 1. Circular Linked List
2. Circular Linked List - Implementation
 Circular Linked List
• Circular linked list is a linked list where all nodes are connected to form a
circle.

• There is no NULL at the end. 

• A circular linked list can be a singly circular linked list or doubly circular
linked list.
 Advantages of Circular Linked Lists
• Any node can be a starting point.

• We can traverse the whole list by starting from any point.

• We just need to stop when the first visited node is visited again.

•  Useful for implementation of queue.

• For example, when multiple applications are running on a PC

 OPERATIONS ON CIRCULARLY LINKED LIST

• Insertion
• Deletion
• Display

Circular linked list – Creation

temp=head;
temp->next = new;
new -> next = head;
 Insertion in a Circular Linked List

1. Inserting At Beginning of the list

2. Inserting At End of the list

3. Inserting At Specific location in the list

 Inserting At Beginning of the list
Steps to insert a new node at beginning of the circular linked list.

Step 1 - Create a newNode with given value.

Step 2 - Check whether list isEmpty (head == NULL)

Step 3 - If it is Empty then, set head = newNode and newNode→next = head 

Step 4 - If it is Not Empty then, define a Node pointer 'temp' and initialize with 'head‘

Step 5 - Keep moving the 'temp' to its next node until it reaches to the last node
(until 'temp → next == head').

Step 6 - Set 'newNode → next =head', 'head = newNode' and 'temp → next = head'.

 Inserting At the End of the list
• Steps to insert a new node at end of the circular linked list.

Step 1 - Create a newNode with given value.

Step 2 - Check whether list is Empty (head == NULL)

Step 3 - If it is Empty then, set head = newNode and newNode → next = head

Step 4 - If it is Not Empty then, define a node pointer temp and initialize

with head

Step 5 - Keep moving the temp to its next node until it reaches to the last node in
the list (until temp → next == head)

Step 6 - Set temp → next = newNode and newNode → next = head

 Inserting At Specific location in the list (After a Node)

Step 1 - Create a newNode with given value

Step 2 - Check whether list is Empty (head == NULL)

Step 3 - If it is Empty then, set head = newNode and newNode → next = head.

Step 4 - If it is Not Empty then, define a node pointer temp and initialize

with head

Step 5 - Keep moving the temp to its next node until it reaches to the node after which
we want to insert the newNode (until temp1 → data is equal to location, here
location is the node value after which we want to insert the newNode).
 Inserting At Specific location in the list (After a Node)

Step 6 - Every time check whether temp is reached to the last node or not. If it is reached
to last node then display 'Given node is not found in the list!!!

Insertion not possible!!!' and terminate the function.

Otherwise move the temp to next node.

Step 7 - If temp is reached to the exact node after which we want to insert the newNode then
check whether it is last node (temp → next == head).

Step 8 - If temp is last node then set temp → next = newNode and 

newNode → next = head

Step 9 - If temp is not last node then set newNode → next = temp → next 

and temp → next = newNode.
 Circular Linked List
Insertion (ROUTINE)
Insertion at first:
new->next = head
head =new;
temp->next= head;

Insertion at middle:
n1->next = new;
new->next = n2;
n2->next = head;

Insertion at last:
n2->next=new;
new->next = head;
 Circular Linked List
Deletion Operation
• In a circular linked list, the deletion operation can be performed in three ways
those are as follows.

1. Deleting from Beginning of the list

2. Deleting from End of the list

3. Deleting a Specific Node

 DELETING FROM BEGINNING OF THE LIST
• The following steps to delete a node from beginning of the circular linked list.

Step 1 - Check whether list is Empty (head == NULL)

Step 2 - If it is Empty then, display 'List is Empty!!! Deletion is not possible' and terminate

the function

Step 3 - If it is Not Empty then, define two Node pointers 'temp1' and 'temp2' and initialize both
'temp1' and 'temp2' with head

Step 4 - Check whether list is having only one node (temp1 → next == head)

Step 5 - If it is TRUE then set head = NULL and delete temp1 (Setting Empty list conditions)

Step 6 - If it is FALSE move the temp1 until it reaches to the last node. (until temp1

→ next == head )

Step 7 - Then set head = temp2 → next, temp1 → next = head and delete temp2

 DELETING FROM END OF THE LIST
• The following steps to delete a node from end of the circular linked list.

Step 1 - Check whether list is Empty (head == NULL)

Step 2 - If it is Empty then, display 'List is Empty!!! Deletion is not possible' and terminate the
function.

Step 3 - If it is Not Empty then, define two Node pointers 'temp1' and 'temp2' and initialize
'temp1' with head

Step 4 - Check whether list has only one Node (temp1 → next == head)

Step 5 - If it is TRUE. Then, set head = NULL and delete temp1. And terminate from the function.
(Setting Empty list condition)

Step 6 - If it is FALSE. Then, set 'temp2 = temp1 ' and move temp1 to its next node. Repeat the same
until temp1 reaches to the last node in the list. (until temp1 → next == head)

Step 7 - Set temp2 → next = head and delete temp1.

 DELETING A SPECIFIC NODE FROM THE LIST
• The following steps to delete a specific node from the circular linked list...
Step 1 - Check whether list is Empty (head == NULL)
Step 2 - If it is Empty then, display 'List is Empty!!! Deletion is not possible' and
terminate the function
Step 3 - If it is Not Empty then, define two Node pointers 'temp1' and 'temp2' and
initialize 'temp1' with head
Step 4 - Keep moving the temp1 until it reaches to the exact node to be deleted or
to the last node. And every time set 'temp2 = temp1' before moving the 'temp1' to
its next node.
Step 5 - If it is reached to the last node then display 'Given node not found in the
list! Deletion not possible!!!'. And terminate the function.
Step 6 - If it is reached to the exact node which we want to delete, then check
whether list is having only one node (temp1 → next == head)
 DELETING A SPECIFIC NODE FROM THE LIST
Step 7 - If list has only one node and that is the node to be deleted then
set head = NULL and delete temp1 (free(temp1)).
Step 8 - If list contains multiple nodes then check whether temp1 is the first node
in the list (temp1 == head).
Step 9 - If temp1 is the first node then set temp2 = head and keep
moving temp2 to its next node until temp2 reaches to the last node. Then set head
= head → next, temp2 → next = head and delete temp1.
Step 10 - If temp1 is not first node then check whether it is last node in the list
(temp1 → next == head).
Step 11- If temp1 is last node then set temp2 → next = head and
delete temp1 (free(temp1)).
Step 12 - If temp1 is not first node and not last node then set temp2 →
next = temp1 → next and delete temp1 (free(temp1)).
 Circular Linked List - Deletion Operation

//delete first item //mark next to first link as first

struct node * deleteFirst() { head = head->next;

//save reference to first link //return the deleted link

struct node *tempLink = head; return tempLink;

if(head->next == head){ }
head = NULL;
return tempLink;
}
Deleting first node from Singly Circular Linked List
• Given a Circular Linked List. The task is to write programs to delete nodes from this list
present at:

• First position.
• Last Position.
• At any given position i.
Deleting the last node of the Circular Linked List
Deleting nodes at given index in the Circular
linked list
 Array versus Linked Lists

• Linked lists are more complex to code and manage than arrays, but they
have some distinct advantages.

• Dynamic: a linked list can easily grow and shrink in size.

• We don’t need to know how many nodes will be in the list. They are created in memory as
needed.
• In contrast, the size of a C++ array is fixed at compilation time.

• Easy and fast insertions and deletions

• To insert or delete an element in an array, we need to copy to temporary variables to make
room for new elements or close the gap caused by deleted elements.
• With a linked list, no need to move other nodes. Only need to reset some pointers.
1. Applications of Circular List -Joseph
Problem
2. Doubly Linked List
 Josephus Circle using circular linked list

• There are n people standing in a circle waiting to be executed. The counting out begins at
some point in the circle and proceeds around the circle in a fixed direction. In each step, a
certain number of people are skipped and the next person is executed. The elimination
proceeds around the circle (which is becoming smaller and smaller as the executed people
are removed), until only the last person remains, who is given freedom. Given the total
number of persons n and a number m which indicates that m-1 persons are skipped and m-
th person is killed in circle. The task is to choose the place in the initial circle so that you are
the last one remaining and so survive.
Example
 Josephus Problem - Snippet
int josephus(int m, node *head)
{ f->next=head->next;
node *f; //sequence in which nodes getting
int c=1; deleted
while(head->next!=head)
{ printf("%d->",head->data);
c=1;
head=f->next;
while(c!=m)
}
{
f=head;
printf("\n");
head=head->next; printf("Winner is:%d\n",head->data);
c++; return;
} }
Exercise
• Write a C program to implement the following operations using
Circular Linked List
• Insertion in all the positions like start , middle and end
• Deletion in all the positions like start , middle and end
• Display
Quiz
1. Find the concept which is right for the below condition.“Any node can be a starting point.
We can traverse the whole list by starting from any point. We just need to stop when the
first visited node is visited again”.
• Circular Linked List
• Singly Linked List
• Stack
• Queue

2. What is the right statement (condition) to check the last node in the circular linked list.
(Assume temp is initialized as temp=head)
• temp->next=NULL
• temp->next=head
• temp=NULL
• temp=head
Quiz
3. Find the code used to count the nodes in the circular linked list.
Doubly Linked List
Doubly Linked list - Motivation
• Doubly linked lists are useful for playing video and sound files with “rewind” and
“instant replay”

• They are also useful for other linked data which require “rewind” and “fast
forward” of the data
 Doubly Linked Lists
• Doubly linked lists
• Each node contains
• a value,
• a link to its successor (if any), and
• a link to its predecessor
• There are two NULL: at the first and last nodes in the list
• Advantage: given a node, it is easy to visit its predecessor. Convenient to traverse
lists backwards

Address of next node

info

NULL 6 12 NULL
13

Address of
previous node

Head
Operations - Doubly Linked List
• Create a Node
• Insertion at beginning of a list
• Insertion at end of the list
• Insertion after a given position
• Delete a node from beginning
• Delete a node from end
• Delete a node from any location
 Creating a Node
struct node
{
struct node *previous; • info: the user's data
int info;
struct node *next; • next, previous: the address of
}
void display(struct node *head) the next and previous node in
{ the list
struct node *P; .info .next
If (head==NULL) .back
{
printf(List is empty \n”); previous info next
return;
}
P=head;
printf(“List is: \t”);
while(P!=NULL)
{ printf(“%d”, P->info);
P=P->next;
}
}
Insertion at Beginning • Time Complexity –O(1)

struct node *insertAtBeginning (struct node *head,

int data)
{
struct node *temp;
temp=(struct node*)malloc(sizeof (struct node));
temp->info=data;
temp->previous=NULL;
temp->next=head; //starts pointing to head of list
If(head)
head->previous=temp;
head=temp;
return head;
}
 Insertion at end
• Time Complexity – O(n)
struct node *insertAtEnd (struct node *head, int data)
{
struct node *temp, *P;
temp=(struct node*)malloc(sizeof (struct node));
temp->info=data;
P=head;
if(P)
{
while(P->next!=NULL)
{ P = P->next; }
P->next=temp;
temp->previous = P;
} info
else
head=temp; NULL 13 6 12
return head;
} 8 NULL

Last
Head
 Insertion after a given item
struct node *insertAfterItem(Struct node *head, int data, int item)
{
P= P->next;
struct node *temp, *P;
}
temp=(Struct node*)malloc(sizeof(struct node));
temp->info=data;
printf(“%d not present in the list \n \n”, item);
P=head; return head;
while(P!=NULL) }
{ • Time Complexity –O(n)
If(P->info==item)
{
temp->previous=P;
temp->next=P->next;
P->next->previous==temp;
P->next=temp;
return head;
}
Head 13 6 12 NULL
NULL
P

temp Last
Deletion
Find the node to delete
Adjust the pointers
Delete the node(freeing the memory space allotted to the node) by calling free()
Deletion of first node
struct node *delete(Struct node *head, int data)
{
struct node *temp;
if(head==NULL)
{ • Time Complexity – O(1)
printf(“List is empty”);
return head;
}
if(head->info==data)
{
temp=head;
head=head->next;
head->previous=NULL;
free(temp);
return head;
}
}
 Deletion of a node in the middle
struct node *deleteItemNode(Struct node *head, int data)
{
temp=head;
while(temp->next!=NULL)
{
if(temp->info==data)
{
temp->previous->next=temp->next;
temp->next->previous=temp->previous;
free(temp);
return head;
}
temp=temp->next;
13 6 12 8
}

NULL
 Deletion of a node at end
int deleteFromEnd()
{
struct node *temp;
temp = head;
while(temp->next!=NULL)
temp=temp->next;
printf("\nData deleted from list is %d \n",temp->data);
temp->previous->next=NULL;
free(temp);
return 0;
} 

13 6 12

8
NULL
Searching a node
int searchList(struct Node* head, int search)
{
     struct Node *temp = head;
              int flag=0,value;
              if(temp == NULL)  
         return -1;
     else {
          while(temp->next != NULL)
         {
                     
                         if(temp->info == search)
             {
                 flag = 1;
                   break;
             }
                     temp = temp->next;  
         }
if(flag == 1)
  printf(“%d Search node is found \n”);          
        else
            printf(“%d Search node is not found \n”);
    }
}
                
Advantages and Dis advantages of Doubl y L inked Li st

• Advantages: 

1. We can traverse in both directions i.e. from starting to end and as well as from end to starting.
2. It is easy to reverse the linked list.
3. If we are at a node, then we can go to any node. But in linear linked list, it is not possible to
reach the previous node. 

Disadvantages: 

1. It requires more space per space per node because one extra field is required for pointer to
previous node.
2. Insertion and deletion take more time than linear linked list because more pointer operations
are required than linear linked list. 
Review Questions
1) How do you calculate the pointer difference in a memory efficient double linked list?
a) head xor tail b) pointer to previous node xor pointer to next node
c) pointer to next node - pointer to previous node
d) pointer to previous node - pointer to next node

2) What is the time complexity of inserting a node in a doubly linked list?

a) O(nlogn) b) O(logn) c) O(n) d) O(1)

3) Consider the following doubly linked list: head-1-2-3-4-5-tail

Node temp = new Node(6, head, head.next()); Node temp1 = new Node(0, tail.getPrev(), tail);
head.setNext(temp); temp.getNext().setPrev(temp); tail.setPrev(temp1);
temp1.getPrev().setNext(temp1);
a) head-0-1-2-3-4-5-6-tail b) head-1-2-3-4-5-6-tail
c) head-6-1-2-3-4-5-0-tail d) head-0-1-2-3-4-5-tail
Review Questions … Contd.
4) What is a memory efficient double linked list?
a) Each node has only one pointer to traverse the list back and forth.
b) The list has breakpoints for faster traversal
c) An auxiliary singly linked list acts as a helper list to traverse through the doubly linked list
d) None of these

5) Which of the following is false about a doubly linked list?

a) We can navigate in both the directions
b) It requires more space than a singly linked list
c) The insertion and deletion of a node take a bit longer
d) Implementing a doubly linked list is easier than singly linked list
Exercises
• Sort the DLL in ascending order.
• Count the number of nodes in the given DLL.
• Reverse all nodes in doubly linked list
• Swap Kth node from beginning with Kth node from end in a Linked List
• Insert value in sorted way in a sorted doubly linked list
• Remove duplicates from an unsorted doubly linked list
• Count triplets in a sorted doubly linked list whose sum is equal to a given value x
• Check if a doubly linked list of characters is palindrome or not
References
1. Seymour Lipschutz, Data Structures with C, McGraw Hill, 2014
2. Mark Allen Weiss, Data Structures and Algorithm Analysis in C, 2nd ed.,
Pearson Education, 2015
3. https://cse.iitkgp.ac.in/~palash/Courses/2020PDS/PDS2020.html
4. http://www.btechsmartclass.com/data_structures
5. https://www.geeksforgeeks.org/
THANK YOU