UNIT -4 Singly Linked List-kiruthika.pptx

LINKED LIST Definition:
• A linked list is a linear data structure where each element is a
separate object.
• Linked list elements are not stored at contiguous location;
the
elements are linked using pointers.
• LINKED LIST is a collection of data elements called nodes
where the linear order is given by means of pointer.
• Each node of a list is made up of two items - the data and
a reference to the next node.
• The last node has a reference to null.

Chandigarh Group of Colleges, Landran

Example of LINKED List:

Representation of Linear Linked

Example of linked list :

Types of Linked list:
• Linear or Singly linked list
• Circular Linked List
• Doubly Linked list

Singly or Linear linked list
VS
Circular
Linked
List:

CS 10001 : Programming and Data Stru
ctures
10
Lecture #05: © DSamanta
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

11
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.

Single or Linear linked list
VS
Double Linked List:

13
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

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.

ctures
16
Operations on single linked list
• Creating a Node
• 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.

ctures
17
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?

18
newNode = (struct node *)malloc(sizeof(struct node));
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;
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

ctures
19
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);

ctures
20
Example 1: Creating a Single Linked List
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;
}
}

ctures
21
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;

ctures
22
Example 1: Illustration
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

ctures
23
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;
}

ctures
24
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
}
}
}

TRAVERSING A LINKED LIST EXAMPLE:

ctures
26
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

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

ctures
28
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.

ctures
29
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)
{
printf("Unable to allocate memory.");
}
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");
}
}

ctures
30
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).

ctures
31
Insertion at End
/* Create a new node and insert at the end of the linked list. */
void insertNodeAtEnd(int data)
{
struct node *newNode, *temp;
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
}
}

ctures
32
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.

ctures
33
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.

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

ctures
35
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");
}
}
}

ctures
36
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.

ctures
37
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.

ctures
38
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).

ctures
39
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.

ctures
40
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");
}
}

ctures
41
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

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

ctures
43
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);
}

ctures
44
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).

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

ctures
46
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;
}

ctures
47
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.");
}
}
}

UNIT -4 Singly Linked List-kiruthika.pptx

More Related Content

Similar to UNIT -4 Singly Linked List-kiruthika.pptx (20)

Recently uploaded (20)

UNIT -4 Singly Linked List-kiruthika.pptx