Data Structures_Linear data structures Linked Lists.pptx

Unit II: Linear Data Structures
Dr. Rushali A. Deshmukh

*CONTENTS
Concept of Linear Data Structures,
Array as an ADT,
Merging of two arrays,
Storage Representation,
Linear list – singly linked list implementation, insertion, deletion
and searching operations on linear list,
circularly linked lists- Operations for Circularly linked lists,
doubly linked list implementation, insertion, deletion and
searching operations, applications of linked lists
JSPM's RSCOE

* Introduction
Data Structure can be classified as:
 linear
 non-linear
Linear (elements arranged in sequential in memory
location) i.e. array & linear link-list
Non-linear such as a tree and graph.
Operations:
 Traversing, Searching, Inserting, Deleting,
Sorting, Merging
Array is used to store a fix size for data and a link-list the
data can be varies in size.
JSPM's RSCOE

* Introduction
Advantages of an Array:
a) Very simple
b) Economy – if full use of memory
c) Random accessed at the same time
Disadvantage: wasting memory if not fully used
JSPM's RSCOE

* Linear Array
Homogeneous data:
a) Elements are represented through indexes.
b) Elements are saved in sequential in memory locations.
Number of elements, N –> length or size of an array.
If:
UB : upper bound ( the largest index)
LB : lower bound (the smallest index)
Then: N = UB – LB + 1
Length = N = UB when LB = 1
JSPM's RSCOE

* Linear Array
All elements in A are written symbolically as, 1 .. n is the
subscript.
A1, A2, A3, .... , An
i.e., FORTRAN, PL/1 and BASIC  A(1), A(2), ..., A(N)
Java  A[0], A[1], ..., A[N-1] , subscript starts from 0
LB = 0, UB = N–1
JSPM's RSCOE

* Representation of Array in a Memory
The process to determine the address in a memory:
a) First address – base address.
b) Relative address to base address through index function.
Example: char X[100];
Let char uses 1 location storage.
If the base address is 1200 then the next element is in 1201.
Index Function is written as:
Loc (X[i]) = Loc(X[0]) + i , i is subscript and LB = 0
1200 1201 1202 1203
X[0] X[1] X[2]
JSPM's RSCOE

* Representation of Array in a Memory
 In general, index function:
Loc (X[i]) = Loc(X[LB]) + w*(i-LB);
where w is length of memory location required.
For real number: 4 byte, integer: 2 byte and
character: 1 byte.
 Example:
If LB = 5, Loc(X[LB]) = 1200, and w = 4, find
Loc(X[8]) ? Loc(X[8])= Loc(X[5]) + 4*(8 – 5)
= 1212
JSPM's RSCOE

* Traversing Algorithm
 Traversing operation means visit every element once.
e.g. to print, etc.
 Example algorithm:
JSPM's RSCOE
1. [Assign counter]
K=LB // LB = 0
2. Repeat step 2.1 and 2.2 while K <= UB // If LB = 0
2.1 [visit element]
do PROCESS on LA[K]
2.2 [add counter]
K=K+1
3. end repeat step 2
4. exit

* Insertion Algorithm
 Insert item at the back is easy if there is a space. Insert item in the
middle requires the movement of all elements to the right as in Figure
1.
JSPM's RSCOE

* Deletion Algorithm
 Deleting an element does not affect the size of array.
 It is also checked whether deletion is possible or not.
JSPM's RSCOE

* Deletion Algorithm
Visual Representation
Let's take an array of 5 elements.
1, 20, 5, 78, 30.
If we remove element 20 from the array, the execution will be,
JSPM's RSCOE

* MULTIDIMENSIONALARRAY
Two or more subscripts.
JSPM's RSCOE

*2-D ARRAY
A 2-D array, A with m X n elements.
In math application it is called matrix.
In business application – table.
Example:
Assume 25 students had taken 4 tests.
The marks are stored in 25 X 4 array locations:
JSPM's RSCOE
U0 U1 U2 U3
Stud 0 88 78 66 89
Stud 1 60 70 88 90
Stud 2 62 45 78 88
.. .. .. .. ..
.. .. .. .. ..
Stud 24 78 88 98 67
n
m

*2-D ARRAY
Multidimensional array declaration in Java:-
int [][] StudentMarks = new int [25][4];
StudentMarks[0][0] = 88;
StudentMarks[0][1] = 78;…..
OR
int [][] StudentMarks = {{88, 78, 66, 89},
{60, 70, 88, 90},…}
JSPM's RSCOE

*2-D ARRAY
the 2-D array is visualized as follows:
JSPM's RSCOE
…
[0
]
[1]
[2]
[3]
[4]
[5]
[6
]
[24]
StudentMarks
88 78 66 89
60 70 88 90
62 45 78 88
[0] [1] [2] [3]

* Higher-Dimensional
Arrays
JSPM's RSCOE
Multiple dimensions get difficult to visualize graphically.
•
double Coord[100][100][100];

Linked List
• A linked list is a data structure which allows to store data
dynamically and manage data efficiently.
• Typically, a linked list, in its simplest form looks like the
following
A B C NULL
header

Linked List
•Few salient features
• There is a pointer (called header) points the first element (also called node)
• Successive nodes 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, consume exactly what it needs.

Array: Contagious Storage
10
15
20
22
25
30
35
40
45
50
arrayName
0
1
2
3
4
5
6
7
8
9

Array versus Linked Lists
• In arrays
• elements are stored in a contagious memory locations
• Arrays are static data structure unless we use dynamic memory
allocation
• Arrays are suitable for
 Inserting/deleting an element at the end.
 Randomly accessing any element.
 Searching the list for a particular value.

Linked List: Non-Contagious Storage
15
45
25
50
22
35
30
20
10
a
b
c
d
e
f
g
h
i
j
40
k
15
45
25
50
22
35
30
20
10
h a c
d
e
f
g
b
i
40
k
15
45
25
50
22
35
30
20
10
h
a c
d
e f
g
i
40
k b
15
45
25
50
22
35
30
20
10
h
40

Array versus Linked Lists
• In Linked lists
• adjacency between any two elements are maintained by means of links
or pointers
• It is essentially a dynamic data structure
• Linked lists are suitable for
 Inserting an element at any position.
 Deleting an element from any where.
 Applications where sequential access is required.
 In situations, where the number of elements cannot be predicted beforehand.

Defining a Node of a Linked List
Each structure of the list is called a node, and consists of two fields:
• Item (or) data
• Address of the next item in the list (or) pointer to the next node in the
list
struct node
{
int data; /* Data */
struct node *next; /* pointer*/
} ;
Data
next
node
Note:
Such structures which contain a member field pointing to the same structure type are
called self-referential structures.
How to define a node of a linked list?

Types of Lists: Single Linked List
Depending on the way in which the links are used to maintain
adjacency, several different types of linked lists are possible.
Single linked list (or simply linked list)
• A head pointer addresses the first element of the list.
• Each element points at a successor element.
• The last element has a link value NULL.
A B C NULL
head

Types of Lists: Double Linked List
Double linked list
• Pointers exist between adjacent nodes in both directions.
• The list can be traversed either forward or backward.
• Usually two pointers are maintained to keep track of the list, head and
tail.
A B C
head tail

Defining a Node of a Double Linked List
Each node of doubly linked list (DLL) consists of three fields:
• Item (or) Data
• Pointer of the next node in DLL
• Pointer of the previous node in DLL
struct node
{
int data;
struct node *next; // Pointer to next node in DLL
struct node *prev; // Pointer to previous node in DLL
};
Data
next
node
How to define a node of a doubly linked list (DLL)?
prev

Double Linked List
• Doubly linked list is a collection of nodes linked together in a sequential way.
• Doubly linked list is almost similar to singly linked list except it contains two
address or reference fields, where one of the address field contains reference of
the next node and other contains reference of the previous node.
• First and last node of a linked list contains a terminator generally a NULL
value, that determines the start and end of the list.
• Doubly linked list is sometimes also referred as bi-directional linked list since it
allows traversal of nodes in both direction.
• Since doubly linked list allows the traversal of nodes in both direction, we can
keep track of both first and last nodes.

Double versus Single Linked List
Advantages over singly linked list
1) A DLL can be traversed in both forward and backward direction.
2) The delete operation in DLL is more efficient if pointer to the node to be deleted
is given.
Disadvantages over singly linked list
3) Every node of DLL Require extra space for an previous pointer.
4) All operations require an extra pointer previous to be maintained.

Types of Lists: Circular Linked List
Circular linked list
•The pointer from the last element in the list points back to
the first element.
A B C
head

Circular Linked List
• A circular linked list is basically a linear linked list that may be single- or
double-linked.
• The only difference is that there is no any NULL value terminating the list.
• In fact in the list every node points to the next node and last node points to the
first node, thus forming a circle. Since it forms a circle with no end to stop it is
called as circular linked list.
• In circular linked list there can be no starting or ending node, whole node can be
traversed from any node.
• In order to traverse the circular linked list, only once we need to traverse entire
list until the starting node is not traversed again.
• A circular linked list can be implemented using both singly linked list and
doubly linked list.

Example 1: Creating a Single Linked List
Linked list to store and print roll number, name and age of 3 students.
#include <stdio.h>
struct stud
{
int roll;
char name[30];
int age;
struct stud *next;
};
main()
{
struct stud n1, n2, n3;
struct stud *p;
scanf (“%d %s %d”, &n1.roll, n1.name, &n1.age);
scanf (“%d %s %d”, &n2.roll,n2.name, &n2.age);
scanf (“%d %s %d”, &n3.roll,n3.name, &n3.age);

n1.next = &n2 ;
n2.next = &n3 ;
n3.next = NULL ;
/* Now traverse the list and print the elements */
p = &n1 ; /* point to 1st element */
while (p != NULL)
{
printf (“n %d %s %d”, p->roll, p->name, p->age);
p = p->next;
}
}

Example 1: Illustration
The structure:
struct stud
{
int roll;
char name[30];
int age;
struct stud *next;
};
Also assume the list with three nodes n1, n2 and n3 for 3 students.
struct stud n1, n2, n3;

To create the links between nodes, it is written as:
n1.next = &n2 ;
n2.next = &n3 ;
n3.next = NULL ; /* No more nodes follow */
• Now the list looks like:
roll
name
age
next
n1 n2 n3
NULL

C-program to store 10 values on a linked list reading the data from keyboard.
#include <stdio.h>
#include <stdlib.h>
struct node {
int data; //Data part
struct node *next; //Address part
}*header;
void createList(int n); /* Functions to create a list*/
int main()
{
int n;
printf("Enter the total number of nodes: ");
scanf("%d", &n);
createList(n);
return 0;
}

void createList(int n)
{
struct node *newNode, *temp;
int data, i;
/* A node is created by allocating memory to a structure */
newNode = (struct node *)malloc(sizeof(struct node));
/* If unable to allocate memory for head node */
if(newNode == NULL)
{
printf("Unable to allocate memory.");
}
else
{
printf("Enter the data of node 1: ");
scanf("%d", &data);
newNode->data = data; //Links the data field with data
newNode->next = NULL; //Links the address field to NULL
header = newNode; //Header points to the first node
temp = newNode; //First node is the current node

for(i=2; i<= n; i++)
{
/* A newNode is created by allocating memory */
if(newNode == NULL)
{
break;
}
else
{
printf("Enter the data of node %d: ", i);
scanf("%d", &data);
newNode->data = data; //Links the data field of newNode with data
newNode->next = NULL; //Links the address field of newNode with NULL
temp->next = newNode; //Links previous node i.e. temp to the newNode
temp = temp->next;
}
}
}
}

• To start with, we have to create a node (the first node), and make header point to
it.
newNode->data = data; //Links the data field with data
header = newNode;
temp = newNode;
header
100 NULL
It creates a single node. For example, if the data entered is 100 then the list
look like

newNode->data = data; //Links the data field of newNode with data
temp = temp->next;
head
100 NULL
If we need n number of nodes in the linked list:
• Allocate n newNodes, one by one.
• Read in the data for the newNodes.
• Modify the links of the newNodes so that the chain is formed.
It creates n number of nodes . For e.g. if the data entered is 200, 50, 30 then
the list look like
200 50 30
Creating a single linked list

C-program to copy an array to a single linked list.
#include <stdio.h>
#include <stdlib.h>
struct node {
int data; //Data part
struct node *next; //Address part
};
int main()
{
struct node *header, *newNode, *temp;
int data, i, n, a[100];
printf("Enter the total number of data: ");
scanf("%d", &n);
// Write code here to initialize the array a with n elements //
...

/* A node is created by allocating memory to a structure */
/* If unable to allocate memory for head node */
if(newNode == NULL)
{
}
else
{
newNode->data = a[0]; //Links the data field with data
header = newNode; //Header points to the first node
temp = header;

for(i = 1; i <= n; i++)
{
/* A newNode is created by allocating memory */
if(newNode == NULL)
{
break;
}
else
{
newNode->data = a[i]; //Links the data field of newNode with a[i]
temp = temp->next;
}
}
}
}

Operations on single linked list
• Traversing a list
• Printing, finding minimum, etc.
• Insertion of a node into a list
• At front, end and anywhere, etc.
• Deletion of a node from a list
• At front, end and anywhere, etc.
• Comparing two linked lists
• Similarity, intersection, etc.
• Merging two linked lists into a larger list
• Union, concatenation, etc.
• Ordering a list
• Reversing, sorting, etc.

Single Linked List: Traversing
Once the linked list has been constructed and header points to the
first node of the list,
• Follow the pointers.
• Display the contents of the nodes as they are traversed.
• Stop when the next pointer points to NULL.
The function traverseList(struct Node *) is given in the next
slide. This function to be called from main() function as:
int main()
{
// Assume header, the pointer to the linked list is given as an input
printf("n Data in the list n");
traverseList(header);
return 0;
}

Single linked list: Traversing
void traverseList(struct Node *header)
{
struct node *temp;
/* If the list is empty i.e. head = NULL */
if(header == NULL)
{
printf("List is empty.");
}
else
{
temp = header;
while(temp != NULL)
{
printf("Data = %dn", temp->data); //Prints the data of current node
temp = temp->next; //Advances the position of current node
}
}
}

Single Linked List: Insertion
Insertion steps:
•Create a new node
•Start from the header node
•Manage links to
• Insert at front
• Insert at end
• Insert at any position

Insertion at Front
Steps to insert node at the beginning of singly linked list
Step 1: Create a new node.

Insertion at Front
Step 3: Make the new node as the head node, i.e. now head node will point to newNode.
Step 2: Link the newly created node with the head node, i.e. the newNode will now
point to head node.

Insertion at front
/*Create a new node and insert at the beginning of the linked list.*/
void insertNodeAtBeginning(int data)
{
struct node *newNode;
newNode = (struct node*)malloc(sizeof(struct node));
if(newNode == NULL)
{
}
else
{
newNode->data = data; //Links the data part
newNode->next = head; //Links the address part
head = newNode; //Makes newNode as first node
printf("DATA INSERTED SUCCESSFULLYn");
}
}

Single Linked List: Insertion at End
Steps to insert node at the end of Singly linked list
Step 1: Create a new node and make sure that the address part of the new node points to
NULL. i.e. newNode->next=NULL
Step 2: Traverse to the last node of the linked list and connect the last node of the list with
the new node, i.e. last node will now point to new node. (lastNode->next =
newNode).

Insertion at End
/* Create a new node and insert at the end of the linked list. */
void insertNodeAtEnd(int data)
{
if(newNode == NULL)
{
}
else
{
newNode->next = NULL;
temp = head;
while(temp->next != NULL) //Traverse to the last node
temp = temp->next;
temp->next = newNode; //Links the address part
}
}

Steps to insert node at any position of Singly Linked List
Step 1: Create a new node.
Single Linked List: Insertion at any Position
Step 2: Traverse to the n-1th
position of the linked list and connect the new node with the
n+1th
node. (newNode->next = temp->next) where temp is the n-1th
node.

Single Linked List: Insertion at any position
Step 3: Now at last connect the n-1th
node with the new node i.e. the n-1th
node will now
point to new node. (temp->next = newNode) where temp is the n-1th
node.

Insertion at any Position
/* Create a new node and insert at middle of the linked list.*/
void insertNodeAtMiddle(int data, int position)
{
int i;
if(newNode == NULL)
{
}
else
{
temp = head;

Insertion at any Position
for(i=2; i<=position-1; i++) /* Traverse to the n-1 position */
{
temp = temp->next;
if(temp == NULL)
break;
}
if(temp != NULL)
{
/* Links the address part of new node */
newNode->next = temp->next;
/* Links the address part of n-1 node */
temp->next = newNode;
}
else
{
printf("UNABLE TO INSERT DATA AT THE GIVEN POSITIONn");
}
}
}

Double Linked List: Insertion at any Position
Steps to insert a new node at nth
position in a Doubly linked list.
Step 1: Traverse to N-1 node in the list, where N is the position to insert. Say temp now
points to N-1th
node.
Step 2: Create a newNode that is to be inserted and assign some data to its data field.

Doubly Linked List: Insertion at any Position
Step 3: Connect the next address field of newNode with the node pointed by next address
field of temp node.
Step 4: Connect the previous address field of newNode with the temp node.

Step 5: Check if temp.next is not NULL then, connect the previous address field of node
pointed by temp.next to newNode.
Step 6: Connect the next address field of temp node to newNode.

Step 7: Final doubly linked list looks like

#include <stdio.h>
#include <stdlib.h>
struct node { /* Basic structure of Node */
int data;
struct node * prev;
struct node * next;
}*head, *last;
int main()
{
int n, data;
head = NULL;
last = NULL;
printf("Enter the total number of nodes in list: ");
scanf("%d", &n);
createList(n); // function to create double linked list
displayList(); // function to display the list
printf("Enter the position and data to insert new node: ");
scanf("%d %d", &n, &data);
insert_position(data, n); // function to insert node at any position
displayList();
return 0;
}

{
int i, data;
struct node *newNode;
if(n >= 1){ /* Creates and links the head node */
head = (struct node *)malloc(sizeof(struct node));
printf("Enter data of 1 node: ");
scanf("%d", &data);
head->data = data;
head->prev = NULL;
head->next = NULL;
last = head;
for(i=2; i<=n; i++){ /* Creates and links rest of the n-1 nodes */
printf("Enter data of %d node: ", i);
scanf("%d", &data);
newNode->data = data;
newNode->prev = last; //Links new node with the previous node
last->next = newNode; //Links previous node with the new node
last = newNode; //Makes new node as last/previous node
}
printf("nDOUBLY LINKED LIST CREATED SUCCESSFULLYn");
}
}

void insert_position(int data, int position)
{
struct node * newNode, *temp;
if(head == NULL){
printf("Error, List is empty!n");
}
else{
temp = head;
if(temp!=NULL){
newNode->next = temp->next; //Connects new node with n+1th node
newNode->prev = temp; //Connects new node with n-1th node
if(temp->next != NULL)
{
temp->next->prev = newNode; /* Connects n+1th node with new node */
}
temp->next = newNode; /* Connects n-1th node with new node */
printf("NODE INSERTED SUCCESSFULLY AT %d POSITIONn", position);
}
else{
printf("Error, Invalid positionn");
}
}
}

void displayList()
{
struct node * temp;
int n = 1;
if(head == NULL)
{
printf("List is empty.n");
}
else
{
temp = head;
printf("DATA IN THE LIST:n");
while(temp != NULL)
{
printf("DATA of %d node = %dn", n, temp->data);
n++;
/* Moves the current pointer to next node */
temp = temp->next;
}
}
}

Few Exercises to Try Out
For doubly linked list write a function to:
• Insert a node at front of the list and at end of the list.
insert_front(data);
insert_end(data);
• Sort the DLL in ascending order.
• Count the number of nodes in the given DLL.

Single Linked List: Deletion
Deletion steps
•Start from the header node
•Manage links to
• Delete at front
• Delete at end
• Delete at any position
•freeingup the node as free space.

Free Memory after Deletion
• Do not forget to free() memory location dynamically allocated
for a node after deletion of that node.
• It is the programmer’s responsibility to free that memory
block.
• Failure to do so may create a dangling pointer – a memory,
that is not used either by the programmer or by the system.
• The content of a free memory is not erased until it is
overwritten.

Steps to delete first node of Singly Linked List
Step 1: Copy the address of first node i.e. head node to some temp variable say toDelete.
Single Linked List: Deletion at Front
Step 2: Move the head to the second node of the linked list (head = head->next).

Step 3: Disconnect the connection of first node to second node.
Single linked list: Deletion at front
Step 4: Free the memory occupied by the first node.

Deletion at Front
/* Delete the first node of the linked list */
void deleteFirstNode()
{
struct node *toDelete;
if(head == NULL)
{
printf("List is already empty.");
}
else
{
toDelete = head;
head = head->next;
printf("nData deleted = %dn", toDelete->data);
/* Clears the memory occupied by first node*/
free(toDelete);
printf("SUCCESSFULLY DELETED FIRST NODE FROM LISTn");
}
}

Steps to delete last node of a Singly Linked List
Step 1: Traverse to the last node of the linked list keeping track of the second last node in
some temp variable say secondLastNode.
Single linked list: Deletion at End
Step 2: If the last node is the head node then make the head node as NULL else disconnect
the second last node with the last node i.e. secondLastNode->next = NULL

Step 3: Free the memory occupied by the last node.
Single linked list: Deletion at End

Deletion at End
/* Delete the last node of the linked list */
void deleteLastNode()
{
struct node *toDelete, *secondLastNode;
toDelete = head;
secondLastNode = head;
while(toDelete->next != NULL) /* Traverse to the last node of the list*/
{
secondLastNode = toDelete;
toDelete = toDelete->next;
}
if(toDelete == head)
{
head = NULL;
}
else
{
/* Disconnects the link of second last node with last node */
secondLastNode->next = NULL;
}
/* Delete the last node */
free(toDelete);
}

Steps to delete a node at any position of Singly Linked List
Step 1: Traverse to the nth
node of the singly linked list and also keep reference of n-1th
node
in some temp variable say prevNode.
Single Linked List: Deletion at any Position
Step 2: Reconnect n-1th
node with the n+1th
node i.e. prevNode->next = toDelete->next
(Where prevNode is n-1th
node and toDelete node is the nth
node and toDelete->next is the n+1th
node).

Single Linked List: Deletion at any Position
Step 3: Free the memory occupied by the nth
node i.e. toDelete node.

Deletion at any Position
/* Delete the node at any given position of the linked list */
void deleteMiddleNode(int position)
{
int i;
struct node *toDelete, *prevNode;
if(head == NULL)
{
printf("List is already empty.");
}
else
{
toDelete = head;
prevNode = head;
for(i=2; i<=position; i++)
{
prevNode = toDelete;
toDelete = toDelete->next;
if(toDelete == NULL)
break;
}

Deletion at any Position
if(toDelete != NULL)
{
if(toDelete == head)
head = head->next;
prevNode->next = toDelete->next;
toDelete->next = NULL;
/* Deletes the n node */
free(toDelete);
printf("SUCCESSFULLY DELETED NODE FROM MIDDLE OF LISTn");
}
else
{
printf("Invalid position unable to delete.");
}
}
}

Single Linked List: Comparing two Lists
Comparing two linked list includes
• Identifying whether the given two linked list are identical.
• Two Linked Lists are identical when they have same data and
arrangement of data is also same.
• Checking whether the lists have same values when the
arrangement is not same.

Comparing two Linked Lists
/* Return true if linked lists a and b are identical, otherwise false */
bool areIdentical(struct node *a, struct node *b)
{
while (a != NULL && b != NULL)
{
if (a->data != b->data)
return false;
/* If we reach here, then a and b are not NULL and their data is same, so
move to next nodes in both lists */
a = a->next;
b = b->next;
}
//If linked lists are identical, then 'a' and 'b' must be NULL at this point.
return (a == NULL && b == NULL);
}
int main()
{
struct node *a, *b;
a = createList(5); // e.g: a: 5->4->3->2->1
b = createList(5); // e.g: b: 5->4->3->2->1
areIdentical(a, b)? printf("Identical"): printf("Not identical");
return 0;
}

Write a function to:
• Concatenate or merge two given list into one big list.
node *concatenate(node *a, node *b);
• Compare two given list with same data but different arrangement.
e.g: a: 5->4->3->2->1
b: 1->2->3->4->5
• Count the number of nodes in the given list using iterative method
and recursive method.

Single Linked List: Reversing
Reversing a list can be performed in two ways:
• Iterative method
• Recursive method
Steps to reverse a Singly Linked List using Iterative method
Step 1: Create two more pointers other than head namely prevNode and curNode that will
hold the reference of previous node and current node respectively.
• Make sure that prevNode points to first node i.e. prevNode = head.
• head should now point to its next node i.e. head = head->next.
• curNode should also points to the second node i.e. curNode = head.

Reversing a List
Step 2: Now, disconnect the first node from others. We will make sure that it points to none.
As this node is going to be our last node. Perform operation prevNode->next = NULL.
Step 3: Move the head node to its next node i.e. head = head->next.

Reversing a List
Step 4: Now, re-connect the current node to its previous node
i.e. curNode->next = prevNode;
Step 5: Point the previous node to current node and current node to head node. Means they
should now point to prevNode = curNode; and curNode = head.

Reversing a List
Step 6: Repeat steps 3-5 till head pointer becomes NULL.
Step 7: Now, after all nodes has been re-connected in the reverse order. Make the last node
as the first node. Means the head pointer should point to prevNode pointer.
• Perform head = prevNode; And finally you end up with a reversed linked list of
its original.

Reversing a List: Iterative Method
void reverseList()
{
struct node *prevNode, *curNode;
if(head != NULL)
{
prevNode = head;
curNode = head->next;
head = head->next;
prevNode->next = NULL; //Makes the first node as last node
while(head != NULL)
{
head = head->next;
curNode->next = prevNode;
prevNode = curNode;
curNode = head;
}
head = prevNode; //Makes the last node as head
printf("SUCCESSFULLY REVERSED LISTn");
}
}

Reversing a List: Recursive Method
/* Function to reverse the linked list */
void Recursive_Reverse(struct node* head)
{
if (head == NULL) // boundary condition to stop recursion
return;
Recursive_Reverse(head->next); // print the list after head node
printf("%d ", head->data); // After everything else is printed, print head
}
/* It should be called from the main() function as */
int main()
{
int n = 10;
createList(n); // creates 10 nodes in the linked list
Recursive_Reverse(head);
return 0;
}

Single Linked List: Sorting
The linked list can be ordered using any of the following sorting
algorithms:
• Insertion sort
• Selection sort
• Merge sort
• Quick sort
• Bubble sort, etc.
Here, we discuss insertion sort for ordering linked list.

Sorting a List using Insertion Sort
// function to sort a singly linked list using insertion sort
void insertionSort(struct node **head_ref)
{
// Initialize sorted linked list
struct node *sorted = NULL;
// Traverse the given linked list and insert every node to be sorted
struct node *current = *head_ref;
while (current != NULL)
{
struct node *next = current->next;
// insert current in sorted linked list
sortedInsert(&sorted, current);
current = next; // Update current
}
// Update head_ref to point to sorted linked list
*head_ref = sorted;
}

/* function to insert a new_node in a list.*/
void sortedInsert(struct node** head_ref, struct node* new_node)
{
struct node* current;
/* Special case for the head end */
if (*head_ref == NULL || (*head_ref)->data >= new_node->data)
{
new_node->next = *head_ref;
*head_ref = new_node;
}
else
{
/* Locate the node before the point of insertion */
current = *head_ref;
while (current->next!=NULL && current->next->data < new_node->data)
{
current = current->next;
}
new_node->next = current->next;
current->next = new_node;
}
}

int main()
{
int n=5;
createList(n);
insertionSort(&head);
printf("nData after sorting the list n");
displayList();
return 0;
}
Output:
Enter the data of node 1: 6
SINGLY LINKED LIST CREATED SUCCESSFULLY

Circular linked list:
Basic structure of singly circular linked list:
Doubly circular linked list:

Circular linked list:
Advantages of a Circular linked list
• Entire list can be traversed from any node.
• Circular lists are the required data structure when we want a list to be accessed
in a circle or loop.
• Despite of being singly circular linked list we can easily traverse to its previous
node, which is not possible in singly linked list.
Disadvantages of Circular linked list
• Circular list are complex as compared to singly linked lists.
• Reversing of circular list is a complex as compared to singly or doubly lists.
• If not traversed carefully, then we could end up in an infinite loop.
• Like singly and doubly lists circular linked lists also doesn’t supports direct
accessing of elements.

Operations on circular linked list
• Creation of list
• Traversal of list
• Insertion of node
• At the beginning of list
• At any position in the list
• Deletion of node
• Deletion of first node
• Deletion of node from middle of the list
• Deletion of last node
• Counting total number of nodes
• Reversing of list

Creation and Traversal of a Circular List
#include <stdio.h>
#include <stdlib.h>
/* Basic structure of Node */
struct node {
int data;
struct node * next;
}*head;
int main()
{
int n, data;
head = NULL;
printf("Enter the total number of nodes in list: ");
scanf("%d", &n);
createList(n); // function to create circular linked list
displayList(); // function to display the list
return 0;
}

Circular Linked List: Creation of List
{
int i, data;
struct node *prevNode, *newNode;
if(n >= 1){ /* Creates and links the head node */
head = (struct node *)malloc(sizeof(struct node));
printf("Enter data of 1 node: ");
scanf("%d", &data);
head->data = data;
head->next = NULL;
prevNode = head;
for(i=2; i<=n; i++){ /* Creates and links rest of the n-1 nodes */
printf("Enter data of %d node: ", i);
scanf("%d", &data);
prevNode->next = newNode; //Links the previous node with newly created node
prevNode = newNode; //Moves the previous node ahead
}
prevNode->next = head; //Links the last node with first node
printf("nCIRCULAR LINKED LIST CREATED SUCCESSFULLYn");
}
}

Circular Linked List: Traversal of List
void displayList()
{
struct node *current;
int n = 1;
if(head == NULL)
{
printf("List is empty.n");
}
else
{
current = head;
printf("DATA IN THE LIST:n");
do {
printf("Data %d = %dn", n, current->data);
current = current->next;
n++;
}while(current != head);
}
}

For circular linked list write a function to:
• Insert a node at any position of the list and delete from the
beginning of the list.
insert_position(data,position);
delete_front();
• Reverse the given circular linked link.

Problems to Ponder…
1. Will be added shortly….

If you try to solve problems yourself, then you will learn
many things automatically.
Spend few minutes and then enjoy the study.

Data Structures_Linear data structures Linked Lists.pptx

More Related Content

Similar to Data Structures_Linear data structures Linked Lists.pptx (20)

More from RushaliDeshmukh2 (15)

Recently uploaded (20)

Data Structures_Linear data structures Linked Lists.pptx