LINKED LIST

Motivation
o Already used Array for storing list of items, which is a Static memory allocation process.
int array[ ] = new int[5]

o Since array is static in nature, we can’t add more elements beyond its capacity.

Limitations of Array
✓Unused memory leads to memory loss
✓Fixed Size
✓Difficulty in inserting and deleting elements in array by means of shifting elements
Example
◦ Let’s consider that we need to store the names of all the students in a class.

◦ As number of students in the class is not given, we may store the names in an array with maximum size let 100.

Fig 1. Array Representation

◦ Let the class contains only 70 students. As a result remaining memory locations are unused.

◦ If 103 students are there, then we can’t store 3 student’s information in the above array of size 100.

◦ Moreover, if we want to shuffle the names in the array, then it’ll be difficult to do so.
Better Solution
o In linked list representation of data, each name are stored in separate non-contiguous memory blocks, and each memory block
is linked to next memory block.

o Linked list representation is done dynamically so that whenever we need/don’t need extra memory block we can add/delete it.

o No need to predefine size of the linked list, so there is no memory loss, again we can add any number of memory blocks to the
linked list because memory blocks are added to the linked list whenever required.

o Moreover insertion at any position is easier. We do not need any shifting operations , only we need to reset some fixed number of
links. For example, if we need to insert name “Dhoni” after “Sikhar” then we need to reset only twolinks.

Fig 2. Linked List

Array vs Linked List
Array Linked List
o Random access of an element is possible because of o Random access of an element is not possible because
the index values. the list must begin from head/start.
o Traversal is fast. o Traversal is slow.
o Fixed size because memory is assigned during o Dynamic size because memory is assigned during
compile time. run time.
o Difficulty in Insertion and deletion of elements. o Ease in insertion and deletion of elements.
o For e.g.- Phone contacts o Use more memory because of the next pointer.
o Nodes are stored non-contiguously, greatly
increasing the time to access elements.
o Difficulty in traversing backward.
o For e.g.- Music playlist

5
Types of Linked List
head

A B C
head
Fig 3. Singly Linked List

A B C

Fig 4. Circular Linked List

head tail

A B C

Fig 5. Doubly Linked List

6
Singly Linked List

o It is a collection of nodes and links.

o A node contains an Info and address of Next node. Info Next

Fig 6. Node of a Single Linked List

Head/Start End/Tail

A B C D NULL
Fig 7. Example of a Linked List
o The last node of the list always contains NULL in its Next section.

o The first node always called as Head/Start and last node is End/Tail.
Operations in Linked List

◦ Create a node
◦ Insertion of new node
♣ At beginning
♣ At end
♣ At any position

◦ Deletion of existing node

♣ From beginning
♣ From end
♣ From any position

◦ Display/Traverse the list

◦ Count the number of nodes in the list
◦ Search an item in the list
◦ Sort the list
◦ Reverse the list
8
Creation
Initially, we must create a node (the first node) and make it as head. head/start
class node info next
{
char info; Fig 8. Node in Single Linked List
node next;
}
head 1045
void create() 1045
{ A null
Scanner sc=new Scanner (System.in);
node head = null; // Initially linked list is empty Fig 9. Example of a Node in Single Linked List
node p = new node(); // Allocate a memory block with address and name it as p.
p.info = sc.next().charAt(0); //Store data value in info part of p
p.next = null; // set the link part to null
head = p; // make p as head
}

9
Insertion of new node
head
63 245 678
At beginning 63
void insert_beg() A 245 B 678 C null
{
node temp = new node();
temp.info = ‘D’; 9080
temp.next = null;
temp D null
temp.next = head;
head = temp; Item to be inserted
}

head

9080 9080 63 245 678

D 63 A 245 B 678 C null

10
Insertion of new node head s s
At end 63 63 245 s 678
void insert_end() A 245 B 678 C null
{
node s = head;
node temp = new node(); 9080
temp.info = ‘D’; temp
temp.next = null; D null
while (s.next != null) Item to be inserted
{
s = s.next;
}
s.next = temp;
}
head
63 245 9080
63 678
A 245 B 678 C 9080 D null
11
Insertion of new node
head s
At any position 63 63 245 s 678
void insert_pos()
{ A 245 B 678 C null
node temp = new node();
temp.info = ‘D’;
temp.next = null;
9080
node s = head; loc = 3
System.out.println("Enter location."); temp D null
int loc = sc.nextInt();
for(int i=1; i < loc-1 && s.next != null; i++) Item to be inserted
{
s = s.next;
}
temp.next = s.next;
s.next = temp;
}
head 245 9080 678
63
63
A 245 B 9080 D 678 C null
12
Display & Count
The list must begin from head.

void display()
{ s
node s = head; s s s
int count = 0;
while (s != null)
{
count ++;
System.out.print (s.info + " -> ");
s = s.next;
}
System.out.print (count);
}

13
Deletion of a node

At beginning
void delete_beg()
{
System.out.println (“Node deleted at” + head);
head = head.next;
}
head
245

14
Deletion
q
At End s s s
void delete_end() q q s
{
node s = head;
node q = new node();
while (s.next != null)
{
q = s;
s = s.next; head
}
System.out.println (“node deleted at: "+ s); 63 63 245 9080
q.next = null;
A 245 B 9080 D null
}

15
Deletion
q
At any position
void delete_pos() s q s s
{
node s = head;
node q = new node();
System.out.println("Enter location.");
int loc = sc.nextInt();
for(int i = 1; i < loc && s.next != null; i++)
{
q = s;
s = s.next;
}
q.next = s.next;
}

16
 Search an Item in the list
void search()
{
node s = head;
if (head = = null)
System.out.println("List is empty.");
else
{ s s
Scanner sc = new Scanner (System.in);
System.out.println ("Enter item to be searched");
char x = sc.next().charAt(0);
while (s != null)
{
if ( x = = s.info) x=B
{
System.out.print (“Item found");
break;
}
s = s.next;
}
}
} 17
 Sort a List
void sort()
{
node s = head; head
node q = new node(); s q s q q
63
while (s != null) 63 245 987 q
{
q = s.next; 56 245 86 987 3 null
while (q != null)
{
if ( s.info > q.info)
{ 86
3 56 56
int x = s.info;
s.info = q.info;
q.info = x;
}
q = q.next;
}
s = s.next;
}
}
18
Reverse a List
void reverse()
{ r r s
node s = new node(); s q s q q s q
node r = new node(); r s
node q = new node();
s = head;
r = null;
r r
while (s != null) null
{
q = s.next;
s.next = r; head
r = s;
s = q; 678
}
head = r; 63 245 9080 678
}
A null B 63 D 245 C 9080

19
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. Suppose the last node is denoted as p. Now, p.next = head.
◦ We can traverse the whole list by starting from any point.
◦ We just need to stop when the first visited node is visited again.

void display()
{
node p = head;
if (head = = null)
System.out,println(“List is empty”); head p
else p p 12463
63 7306
{
do A B C
{ p
System.out.print (p.info + " ");
p = p.next;
} Fig 10. Circular Linked List
while (p != head);
}
}
Doubly Linked List
o A node contains an Info and the address of Previous as well as the Next nodes.
Prev Info Next
o The last node of the list always contains NULL in its Next section.
o The first node always stores NULL in its Prev section. Fig 11. Node of a Double Linked List

class node
{
char info;
node prev, next;
}

head

1234
1234 50 345 10234
null A 50 1234 B 345 50 C 10234 345 D null

Fig 12. Example of a Doubly Linked List

Creation
Initially, we must create a node (the first node) and make it as head.

class node
{
char info;
node next, prev;
}
head 1045
void create() 1045
{ null A null
Scanner sc=new Scanner (System.in);
node head = null; // Initially linked list is empty Fig 13. Node in Doubly Linked List
node p = new node(); // Allocate a memory block with address and name it as p.
p.info = sc.next().charAt(0); //Store data value in info part of p
p.next = null; // set the next part to null
p.prev = null; // set the prev part to null
head = p; // make p as head
}

22
Insertion of new node
head
63 245 678
At beginning 63
void insert_beg() null A 245 63 B 678 245 C null
{
node temp = new node();
temp.info = ‘D’; 9080
temp.prev = null;
temp.next = head; temp null D null
head.prev = temp; Item to be inserted
head = temp;
}

head
9080 9080 63 245 678
null D 63 9080 A 245 63 B 678 245 C null
23
Insertion of new node head s s
At end 245 s 678
63 63
void insert_end()
{ null A 245 63 B 678 245 C null
node s = head;
node temp = new node();
temp.info = ‘D’; 9080
temp.next = null; temp
null D null
while (s.next != null)
{ Item to be inserted
s = s.next;
}
s.next = temp;
temp.prev = s;
}
head
63 245 9080
63 678
null A 245 63 B 678 245 C 9080 678 D null
24
At any position Insertion of new node
void insert_pos()
{ head
node temp = new node();
temp.info = ‘D’;
63 63 s 245 s 678
temp.next = null; 63 B 678
null A 245 245 C null
node s = head;
System.out.println("Enter location.");
int loc = sc.nextInt(); 9080
for(int i=1; i < loc-1 && s.next != null; i++) temp null D null
{
loc = 3
s = s.next; Item to be inserted
}
temp.prev = s;
temp.next = s.next;
s.next.prev = temp;
s.next = temp;
}
63 245 9080 678
head
63 null A 245 63 B 9080 245 D 678 9080 C null
25
 Display
Forward display Backward display
void display() void display()
{ {
node s = head; node s = head;
while (s != null) while (s.next != null)
{ {
System.out.print (s.info + " -> "); s = s.next;
s = s.next; }
} while (s != null)
} {
System.out.print (s.info + " -> ");
s = s.prev;
}
}

26
Deletion of a node

At beginning
void delete_beg()
{
System.out.println (“Node deleted at” + head);
head = head.next;
head.prev = null;
} head
245 245 9080 678
null B 9080 245 D 678 9080 C null

27
Deletion
At End
void delete_end() q s q s q s s
{
node s = head;
node q = new node();
while (s.next != null)
{
q = s;
s = s.next;
}
System.out.println (“node deleted at: "+ s);
q.next = null;
}
head
63 63 245 9080

null A 245 63 B 9080 245 D null

28
Deletion
At any position
void delete_pos() q s q s s
{
node s = head;
node q = new node();
System.out.println("Enter location.");
int loc = sc.nextInt();
for(int i = 1; i < loc && s.next != null; i++)
{
q = s;
s = s.next;
}
q.next = s.next;
s.next.prev = q;
}
head 63 245 678
63
null A 245 63 B 678 245 C null

29