2. Linked Lists.data.structure.algorithm.pdf

Linked Lists
1
DATA STRUCTURES
AND ALGORITHMS

LIST ADT
• What we mean by a "list".
• It is a collection of some elements.
• The most important concept related to lists is that
of position. In other words, we perceive that there is a first
element in the list, a second element, and so on.
• So, we consider a list to be a finite, ordered sequence of data
items known as elements.
• This is close to the mathematical concept of a sequence.
2

LIST ADT
• "Ordered" in this definition means that each element has a
position in the list.
• So the term "ordered" in this context does not mean that the list
elements are sorted by value.
• Each list element must have some data type.
• Although there is no conceptual objection to lists whose elements
have differing data types if the application requires it.
3

LIST ADT
• A list is said to be empty when it contains no
elements.
• The number of elements currently stored is called
the length of the list.
• The beginning of the list is called the head, the end
of the list is called the tail.
4

Basic Operations on LIST ADT
• A list should be able to grow and shrink in size as we insert and
remove elements.
• We should be able to insert and remove elements from anywhere
in the list.
• We should be able to gain access to any element's value, either to
read it or to change it.
• We must be able to create and clear (or reinitialize) lists.
• It is also convenient to access the next or previous element from
the "current" one.
5

Implementations of LIST ADT
• There are two standard approaches to implementing lists:
• the array-based list,
• and the linked list.
• We have already learnt about arrays in detail.
• Now, we will discuss about:
• What linked-list is?
• What are its types?
6

Need for Linked List
• Sometimes you need to store a list of elements in memory.
• Suppose you’re writing an app to manage your to-do's.
• You’ll want to store the to-do's as a list in memory.
• Let’s store the to-do's in an array.
7
■ Using an array means all your tasks
are stored contiguously (right next
to each other) in memory.

• Now suppose you want to add a fourth task.
• But the next location is taken up by someone else’s stuff!
• You have to move to a new spot where you all fit.
8
■ In this case, you need to ask your
computer for a different chunk of memory
that can fit four tasks.
■ Then you need to move all your tasks
there.

• Similarly, adding new items to an array can be a big pain.
• If you’re out of space and need to move to a new spot in memory
every time, adding a new item will be really slow.
9
■ One easy fix is to “hold seats”: even if you
have only 3 items in your task list, you can
ask the computer for 10 slots.
■ Then you can add 10 items to your task list
without having to move.

• This is a good workaround, but you should be aware of a couple of
downsides:
10
 You may not need the extra slots that you
asked for, and then that memory will be
wasted. You aren’t using it, but no one else
can use it either.
 You may add more than 10 items to your
task list and have to move anyway.

• Linked lists solve this problem.
• With linked lists, your items can be anywhere in memory.
• Each item stores the address of the next item in the list.
11
■ A bunch of random memory addresses are
linked together.

• Linked lists solve this problem.
• With linked lists, your items can be anywhere in memory.
• Each item stores the address of the next item in the list.
12
■ A bunch of random memory addresses are
linked together.

• You go to the first address, and it says, “The next item can be found at
address 123.”
• So you go to address 123, and it says, “The next item can be found at
address 847,” and so on.
13
■ With linked lists, you never have to move
your items.

Linked List
• A linked list is a sequence of data structures, which are connected
together via links.
• Each link contains a connection to another link.
14
■ So, it is not just the “actual” value that is
stored; we also store the address of the
next location.
■ Lets call this location as “node” which
contains two parts:
– The actual “data”
– The “pointer” to the next node.
5
data pointer
node

15
A Simple Linked List Class
• We use two classes: Node and List
• Declare Node class for the nodes
• data: double-type data in this example
• next: a pointer to the next node in the list
class Node {
public:
int data; // data
Node* next; // pointer to next
};

Linked List
• It can be visualized as a chain of nodes, where every node points to the
next node.
• There are actual three nodes here; “head” is the pointer that points to
the first node.
• The last node points to “nowhere” or NULL, indicating the end of list.
16

17
A Simple Linked List Class
• Declare List, which contains
• head: a pointer to the first node in the list.
Since the list is empty initially, head is set to NULL
• Operations on List
class List {
public:
List(void) { head = NULL; } // constructor
~List(void); // destructor
bool IsEmpty() { return head == NULL; }
Node* InsertNode(int index, int x);
int FindNode(int x);
int DeleteNode(int x);
void DisplayList(void);
private:
Node* head;
};

Operations on Linked List
1. Searching/Traversing
2. Updation
3. Inserting
1. In empty list
2. In front of list
3. In the middle of list
4. At the end
4. Deleting
1. First Node
2. Middle node
3. Last node
18

Inserting a new node
Node* List::InsertNode(int index, double x) {
if (index < 0) return NULL;
int currIndex = 1;
Node* currNode = head;
while (currNode && index > currIndex) {
currNode = currNode->next;
currIndex++;
}
if (index > 0 && currNode == NULL) return NULL;
Node* newNode = new Node;
newNode->data = x;
if (index == 0) {
newNode->next = head;
head = newNode;
}
else {
newNode->next = currNode->next;
currNode->next = newNode;
}
return newNode;
}
Try to locate index’th
node. If it doesn’t exist,
return NULL.

int currIndex = 1;
currIndex++;
}
newNode->data = x;
if (index == 0) {
head = newNode;
}
else {
}
return newNode;
}
Create a new node

int currIndex = 1;
currIndex++;
}
newNode->data = x;
if (index == 0) {
head = newNode;
}
else {
}
return newNode;
}
Insert as first element
head
newNode

int currIndex = 1;
currIndex++;
}
newNode->data = x;
if (index == 0) {
head = newNode;
}
else {
}
return newNode;
}
Insert after currNode
newNode
currNode

Insert a Value
23
23
23
19 0 4 12 15 NULL
Head
CurrentNode
5
Algorithm InsertNode (Position, Value)

Insert a Value
24
5
19
0
4
12
NULL
Head
Position = 0
Value = 10
int currIndex = 1;
currIndex++;
}
newNode->data = x;
if (index == 0) {
head = newNode;
}
else {
}
return newNode;
}

Insert a Value
25
5
19
0
4
12
NULL
Head
Position = 0
Value = 10
return NULL
int currIndex = 1;
currIndex++;
}
newNode->data = x;
if (index == 0) {
head = newNode;
}
else {
}
return newNode;
}

Insert a Value
26
5
19
0
4
12
NULL
Head
Position = 1
Value = 10
int currIndex = 1;
currIndex++;
}
newNode->data = x;
if (index == 0) {
head = newNode;
}
else {
}
return newNode;
}

Insert a Value
27
5
19
0
4
12
NULL
Head
Position = 1
Value = 10
If Position < 1 Then return NULL
CurrentNode=Head
CurrentPos=1
While CurrentNode != NULL
If CurrentPos == Position Then break
CurrentPos++
CurrentNode = CurrentNode.Next
End while
If CurrentNode == NULL Then return NULL
Create New Node NewNode
NewNode.Data = Value
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
NewNode.Next = CurrentNode.Next
CurrentNode.Next = NewNode
End If

Insert a Value
28
5
19
0
4
12
NULL
Head
Position = 1
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If
Current
Node

Insert a Value
29
5
19
0
4
12
NULL
Head
Position = 1
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If
Current
Node
CurrentPos=1

Insert a Value
30
5
19
0
4
12
NULL
Head
Position = 1
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If
Current
Node
CurrentPos=1

Insert a Value
31
5
19
0
4
12
NULL
Head
Position = 1
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If
Current
Node
CurrentPos=1

Insert a Value
32
5
19
0
4
12
NULL
Head
Position = 1
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If
Current
Node
CurrentPos=1

Insert a Value
33
5
19
0
4
12
NULL
Head
Position = 1
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If
Current
Node
CurrentPos=1
NULL

Insert a Value
34
5
19
0
4
12
NULL
Head
Position = 1
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If
Current
Node
CurrentPos=1
10
NULL
NewNode

Insert a Value
35
5
19
0
4
12
NULL
Head
Position = 1
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If
Current
Node
CurrentPos=1
10
NULL
NewNode

Insert a Value
36
5
19
0
4
12
NULL
Head
Position = 1
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If
Current
Node
CurrentPos=1
10
NewNode

Insert a Value
37
5
19
0
4
12
NULL
Head
Position = 1
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If
Current
Node
CurrentPos=1
10
NewNode

Insert a Value
38
5
19
0
4
12
NULL
Head
Position = 1
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If
Current
Node
CurrentPos=1
10
NewNode

Insert a Value
39
5
19
0
4
12
NULL
Head
Position = 4
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If

Insert a Value
40
5
19
0
4
12
NULL
Head
Position = 4
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If

Insert a Value
41
5
19
0
4
12
NULL
Head
Position = 4
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If
Current
Node

Insert a Value
42
5
19
0
4
12
NULL
Head
Position = 4
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If
Current
Node
CurrentPos=1

Insert a Value
43
5
19
0
4
12
NULL
Head
Position = 4
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If
Current
Node
CurrentPos=1

Insert a Value
44
5
19
0
4
12
NULL
Head
Position = 4
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If
Current
Node
CurrentPos=1

Insert a Value
45
5
19
0
4
12
NULL
Head
Position = 4
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If
Current
Node
CurrentPos=2

Insert a Value
46
5
19
0
4
12
NULL
Head
Position = 4
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If
Current
Node
CurrentPos=2

Insert a Value
47
5
19
0
4
12
NULL
Head
Position = 4
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If
Current
Node
CurrentPos=2

Insert a Value
48
5
19
0
4
12
NULL
Head
Position = 4
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If
Current
Node
CurrentPos=2

Insert a Value
49
5
19
0
4
12
NULL
Head
Position = 4
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If
Current
Node
CurrentPos=3

Insert a Value
50
5
19
0
4
12
NULL
Head
Position = 4
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If
Current
Node
CurrentPos=3

Insert a Value
51
5
19
0
4
12
NULL
Head
Position = 4
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If
Current
Node
CurrentPos=3

Insert a Value
52
5
19
0
4
12
NULL
Head
Position = 4
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If
Current
Node
CurrentPos=3

Insert a Value
53
5
19
0
4
12
NULL
Head
Position = 4
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If
Current
Node
CurrentPos=4

Insert a Value
54
5
19
0
4
12
NULL
Head
Position = 4
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If
Current
Node
CurrentPos=4

Insert a Value
55
5
19
0
4
12
NULL
Head
Position = 4
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If
Current
Node
CurrentPos=4

Insert a Value
56
5
19
0
4
12
NULL
Head
Position = 4
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If
Current
Node
CurrentPos=4

Insert a Value
57
5
19
0
4
12
NULL
Head
Position = 4
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If
CurrentPos=4
Current
Node

Insert a Value
58
5
19
0
4
12
NULL
Head
Position = 4
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If
NULL
CurrentPos=1
Current
Node
NewNode

Insert a Value
59
5
19
0
4
12
NULL
Head
Position = 4
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If
10
NULL
CurrentPos=1
Current
Node
NewNode

Insert a Value
60
5
19
0
4
12
NULL
Head
Position = 4
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If
10
NULL
CurrentPos=1
Current
Node
NewNode

Insert a Value
61
5
19
0
4
12
NULL
Head
Position = 4
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If
10
CurrentPos=1
Current
Node
NewNode

Insert a Value
62
5
19
0
4
12
NULL
Head
Position = 4
Value = 10
CurrentNode=Head
CurrentPos=1
CurrentPos++
End while
If Position == 1
NewNode.Next = Head
Head = NewNode
Else
End If
10
CurrentPos=1
Current
Node
NewNode

Practice Question
• If any function calls InsertValue() and the insert was
successful, how will the calling function know that
the insert was successful.
• May be there is something missing.
• Can you please point out that missing statement in
the algorithm?
63

Searching a Value
• We have learned two searching techniques:
• Sequential Search
• Binary Search
• In linked-lists, we can only do sequential search.
• It is because, linked-list is not a random access data structure.
64

Searching a Value
65
Algorithm SearchNode (Head, KEY)
CurrentNode=Head
Position=1
If CurrentNode.Data == KEY
return Position
End If
Position++
End while
return NULL

Searching a Value
66
CurrentNode=Head
Position=1
return Position
End If
Position++
End while
return NULL
5 19 0 4 12 15 NULL
Head
KEY = 12

Searching a Value
67
CurrentNode=Head
Position=1
return Position
End If
Position++
End while
return NULL
5 19 0 4 12 15 NULL
Head
KEY = 12
CurrentNode

Searching a Value
68
CurrentNode=Head
Position=1
return Position
End If
Position++
End while
return NULL
5 19 0 4 12 15 NULL
Head
Position = 1
KEY = 12
CurrentNode

Searching a Value
69
CurrentNode=Head
Position=1
return Position
End If
Position++
End while
return NULL
5 19 0 4 12 15 NULL
Head
Position = 1
KEY = 12
CurrentNode

Searching a Value
70
CurrentNode=Head
Position=1
return Position
End If
Position++
End while
return NULL
5 19 0 4 12 15 NULL
Head
Position = 1
KEY = 12
CurrentNode

Searching a Value
71
CurrentNode=Head
Position=1
return Position
End If
Position++
End while
return NULL
5 19 0 4 12 15 NULL
Head
Position = 2
KEY = 12
CurrentNode

Searching a Value
72
CurrentNode=Head
Position=1
return Position
End If
Position++
End while
return NULL
5 19 0 4 12 15 NULL
Head
Position = 2
KEY = 12
CurrentNode

Searching a Value
73
CurrentNode=Head
Position=1
return Position
End If
Position++
End while
return NULL
5 19 0 4 12 15 NULL
Head
Position = 2
KEY = 12
CurrentNode

Searching a Value
74
CurrentNode=Head
Position=1
return Position
End If
Position++
End while
return NULL
5 19 0 4 12 15 NULL
Head
Position = 2
KEY = 12
CurrentNode

Searching a Value
75
CurrentNode=Head
Position=1
return Position
End If
Position++
End while
return NULL
5 19 0 4 12 15 NULL
Head
Position = 3
KEY = 12
CurrentNode

Searching a Value
76
CurrentNode=Head
Position=1
return Position
End If
Position++
End while
return NULL
5 19 0 4 12 15 NULL
Head
Position = 3
KEY = 12
CurrentNode

Searching a Value
77
CurrentNode=Head
Position=1
return Position
End If
Position++
End while
return NULL
5 19 0 4 12 15 NULL
Head
Position = 3
KEY = 12
CurrentNode

Searching a Value
78
CurrentNode=Head
Position=1
return Position
End If
Position++
End while
return NULL
5 19 0 4 12 15 NULL
Head
Position = 3
KEY = 12
CurrentNode

Searching a Value
79
CurrentNode=Head
Position=1
return Position
End If
Position++
End while
return NULL
5 19 0 4 12 15 NULL
Head
Position = 4
KEY = 12
CurrentNode

Searching a Value
80
CurrentNode=Head
Position=1
return Position
End If
Position++
End while
return NULL
5 19 0 4 12 15 NULL
Head
Position = 4
KEY = 12
CurrentNode

Searching a Value
81
CurrentNode=Head
Position=1
return Position
End If
Position++
End while
return NULL
5 19 0 4 12 15 NULL
Head
Position = 4
KEY = 12
CurrentNode

Searching a Value
82
CurrentNode=Head
Position=1
return Position
End If
Position++
End while
return NULL
5 19 0 4 12 15 NULL
Head
Position = 4
KEY = 12
CurrentNode

Searching a Value
83
CurrentNode=Head
Position=1
return Position
End If
Position++
End while
return NULL
5 19 0 4 12 15 NULL
Head
Position = 5
KEY = 12
CurrentNode

Searching a Value
84
CurrentNode=Head
Position=1
return Position
End If
Position++
End while
return NULL
5 19 0 4 12 15 NULL
Head
Position = 5
KEY = 12
CurrentNode

Searching a Value
85
CurrentNode=Head
Position=1
return Position
End If
Position++
End while
return NULL
5 19 0 4 12 15 NULL
Head
Position = 5
KEY = 12
CurrentNode

Searching a Value
86
CurrentNode=Head
Position=1
return Position
End If
Position++
End while
return NULL
5 19 0 4 12 15 NULL
Head
Position = 5
KEY = 12
CurrentNode

Searching a Value
87
CurrentNode=Head
Position=1
return Position
End If
Position++
End while
return NULL
5 19 0 4 12 15 NULL
Head
Position = 5
return 5
KEY = 12
CurrentNode

Update a Value
88
Whenever you are at a node, pointed by CurrentNode, updation is easy:
CurrentNode.Data = NewValue
5 19 0 4 12 15 NULL
Head
KEY = 12
CurrentNode

Update a Node’s Value
89
Algorithm UpdateNode (Head, KEY, value)
CurrentNode=Head
CurrentNode.Data = value
End while
return NULL
5 19 0 4 12 15 NULL
Head
KEY = 12
CurrentNode
value = 07

• What if I want to update the value of the 4th Node?
Algorithm UpdateNode (Head, position, value)
90
Update a Node’s Value
90
19 0 4 12 15 NULL
Head CurrentNode
5

Delete a Value
91
91
5 19 0 4 12 15 NULL
Head
CurrentNode
Algorithm DeleteNode (Value)

Delete a Value
92
PrevNode = NULL
CurrentNode = Head
Position = 1
If CurrentNode.Data == Value Then break;
Position++
PrevNode = CurrentNode
End while
If CurrentNode = NULL Then return FALSE
If PrevNode == NULL //First element to be deleted
Head = CurrentNode.Next
Else //Middle or End Element is to be deleted
PreviousNode.Next = CurrentNode.Next
End If
Delete CurrentNode
return TRUE

Delete a Value
93
5
19
0
4
12
NULL
Head
Value = 5
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE

Delete a Value
94
5
19
0
4
12
NULL
Head
Value = 5
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
NULL

Delete a Value
95
5
19
0
4
12
NULL
Head
Value = 5
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
NULL
Current
Node

Delete a Value
96
5
19
0
4
12
NULL
Head
Value = 5
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
NULL
Current
Node
Position=1

Delete a Value
97
5
19
0
4
12
NULL
Head
Value = 5
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
NULL
Current
Node
Position=1

Delete a Value
98
5
19
0
4
12
NULL
Head
Value = 5
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
NULL
Current
Node
Position=1

Delete a Value
99
5
19
0
4
12
NULL
Head
Value = 5
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
NULL
Current
Node
Position=1

Delete a Value
100
5
19
0
4
12
NULL
Head
Value = 5
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
NULL
Current
Node
Position=1

Delete a Value
101
5
19
0
4
12
NULL
Head
Value = 5
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
NULL
Current
Node
Position=1

Delete a Value
102
19
0
4
12
NULL
Head
Value = 5
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
NULL
Position=1

Delete a Value
103
19
0
4
12
NULL
Head
Value = 5
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
NULL
Position=1
return True

Delete a Value
104
5
19
0
4
12
NULL
Head
Value = 12
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE

Delete a Value
105
5
19
0
4
12
NULL
Head
Value = 12
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
NULL

Delete a Value
106
5
19
0
4
12
NULL
Head
Value = 12
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
NULL
Current
Node

Delete a Value
107
5
19
0
4
12
NULL
Head
Value = 12
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
NULL
Current
Node
Position=1

Delete a Value
108
5
19
0
4
12
NULL
Head
Value = 12
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
NULL
Current
Node
Position=1

Delete a Value
109
5
19
0
4
12
NULL
Head
Value = 12
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
NULL
Current
Node
Position=1

Delete a Value
110
5
19
0
4
12
NULL
Head
Value = 12
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
NULL
Current
Node
Position=2

Delete a Value
111
5
19
0
4
12
NULL
Head
Value = 12
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
Current
Node
Position=2

Delete a Value
112
5
19
0
4
12
NULL
Head
Value = 12
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
Current
Node
Position=2

Delete a Value
113
5
19
0
4
12
NULL
Head
Value = 12
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
Current
Node
Position=2

Delete a Value
114
5
19
0
4
12
NULL
Head
Value = 12
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
Current
Node
Position=2

Delete a Value
115
5
19
0
4
12
NULL
Head
Value = 12
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
Current
Node
Position=3

Delete a Value
116
5
19
0
4
12
NULL
Head
Value = 12
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
Current
Node
Position=3

Delete a Value
117
5
19
0
4
12
NULL
Head
Value = 12
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
Current
Node
Position=3

Delete a Value
118
5
19
0
4
12
NULL
Head
Value = 12
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
Current
Node
Position=3

Delete a Value
119
5
19
0
4
12
NULL
Head
Value = 12
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
Current
Node
Position=3

Delete a Value
120
5
19
0
4
12
NULL
Head
Value = 12
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
Current
Node
Position=4

Delete a Value
121
5
19
0
4
12
NULL
Head
Value = 12
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
Current
Node
Position=4

Delete a Value
122
5
19
0
4
12
NULL
Head
Value = 12
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
Current
Node
Position=4

Delete a Value
123
5
19
0
4
12
NULL
Head
Value = 12
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
Current
Node
Position=4

Delete a Value
124
5
19
0
4
12
NULL
Head
Value = 12
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
Current
Node
Position=4

Delete a Value
125
5
19
0
4
12
NULL
Head
Value = 12
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
Current
Node
Position=5

Delete a Value
126
5
19
0
4
12
NULL
Head
Value = 12
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
Current
Node
Position=5

Delete a Value
127
5
19
0
4
12
NULL
Head
Value = 12
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
Current
Node
Position=5

Delete a Value
128
5
19
0
4
12
NULL
Head
Value = 12
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
Current
Node
Position=5

Delete a Value
129
5
19
0
4
12
NULL
Head
Value = 12
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
Current
Node
Position=5

Delete a Value
130
5
19
0
4
12
NULL
Head
Value = 12
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
Current
Node
Position=5

Delete a Value
131
5
19
0
4
12
NULL
Head
Value = 12
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
Current
Node
Position=5

Delete a Value
132
5
19
0
4
12
NULL
Head
Value = 12
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
Current
Node
Position=5

Delete a Value
133
5
19
0
4
NULL
Head
Value = 12
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
Position=5

Delete a Value
134
5
19
0
4
NULL
Head
Value = 12
PrevNode = NULL
CurrentNode = Head
Position = 1
Position++
End while
End If
Delete CurrentNode
return TRUE
PrevNode
Position=5
return True

Advantages of Linked List
• Linked list is a dynamic data structure so it can grow and shrink at
runtime by allocating and deallocating memory. So there is no need
to give initial size of linked list.
• Insertion and deletion of nodes are really easier. Unlike array here we
don’t have to shift elements after insertion or deletion of an element.
In linked list we just have to update the address present in next
pointer of a node.
135

• As size of linked list can increase or decrease at run time so there is
no memory wastage. In case of array there is lot of memory wastage,
like if we declare an array of size 10 and store only 6 elements in it
then space of 4 elements are wasted. There is no such problem in
linked list as memory is allocated only when required.
136

Disadvantages of Linked List
• More memory is required to store elements in linked list as compared
to array. Because in linked list each node contains a pointer and it
requires extra memory for itself.
• Elements or nodes traversal is difficult in linked list. We can not
randomly access any element as we do in array by index. For example
if we want to access a node at position n then we have to traverse all
the nodes before it. So, time required to access a node is large.
137

• In linked list reverse traversing is really difficult. In case of doubly
linked list its easier but extra memory is required for back pointer
hence wastage of memory.
138

Cost of Operations
139
Access Search Insertion Deletion
Array O(1) O(n) O(n) O(n)
Singly Linked List O(n) O(n) O(1) O(1)
Doubly Linked List O(n) O(n) O(1) O(1)

Practice Question
•Suppose, we want a linked list such that whenever we
insert a value, it is inserted in a position such that it is
greater than or equal to the value of previous node
but less than the value of the next node. Such a
linked-list is called an Ordered Linked List. Write an
algorithm for its insert procedure.
140

DATA STRUCTURES AND
ALGORITHMS
Doubly Linked Lists
141

Doubly Linked List
• Doubly Linked List is a variation of Linked list in which navigation is
possible in both ways, either forward and backward easily as
compared to Single Linked List.
142

Operations on Doubly Linked List
2. Updation
3. Inserting
1. In empty list
2. In front of list
4. At the end
4. Deleting
1. First Node
2. Middle node
3. Last node
143

Node data
• info: the user's data
• next, back: the address of the next and
previous node in the list
.back .next
.info

Doubly Linked Lists
• In a Doubly Linked List each item points to both its
predecessor and successor
• prev points to the predecessor
• next points to the successor
10 70
20 55
40
Head
Cur Cur->next
Cur->prev

Node data (cont.)
template<class ItemType>
struct NodeType {
ItemType info;
NodeType<ItemType>* next;
NodeType<ItemType>* back;
};

Finding a List Item
• We no longer need to use prevLocation (we can
get the predecessor of a node using its back
member)

FindItem(listData, item, location, found)
• RetrieveItem, InsertItem, and DeleteItem all require a search !
• Write a general non-member function SearchItem that takes item as a
parameter and returns location and found.
• InsertItem and DeleteItem need location (ignore found)
• RetrieveItem needs found (ignores location)

Finding a List Item (cont.)
void FindItem(NodeType<ItemType>* listData, ItemType item,
NodeType<ItemType>* &location, bool &found)
{
// precondition: list is not empty
bool moreToSearch = true;
location = listData;
found = false;
while( moreToSearch && !found) {
if(item < location->info)
moreToSearch = false;
else if(item == location->info)
found = true;
else {
if(location->next == NULL)
moreToSearch = false;
else
location = location->next;
}
}
}

Inserting into a Doubly Linked List
1. newNode->back = location->back; 3. location->back->next=newNode;
2. newNode->next = location 4. location->back = newNode;

Inserting a Node
• Insert a node New before Cur (not at front or rear)
10 70
20 55
40
Head
New
Cur
New->next = Cur;
New->prev = Cur->prev;
Cur->prev = New;
(New->prev)->next = New;

Special case: inserting in the beginning

void SortedType<ItemType>::InsertItem(ItemType item)
{
NodeType<ItemType>* newNode;
NodeType<ItemType>* location;
bool found;
newNode = new NodeType<ItemType>;
newNode->info = item;
if (listData != NULL) {
FindItem(listData, item, location, found);
if (location->info > item) {
newNode->back = location->back;
newNode->next = location;
if (location != listData) // special case
(location->back)->next = newNode;
else
listData = newNode;
location->back = newNode;
}
(1)
(2)
(3)
(4)
(3)

(cont.)
else { // insert at the end
newNode->back = location;
location->next = newNode;
newNode->next = NULL;
}
}
else { // insert into an empty list
listData = newNode;
newNode->next = NULL;
newNode->back = NULL;
}
length++;
}

Deleting from a Doubly Linked List
• Be careful about the end cases!!

Deleting a Node
• Delete a node Cur (not at front or rear)
(Cur->prev)->next = Cur->next;
(Cur->next)->prev = Cur->prev;
delete Cur;
10 70
20 55
40
Head
Cur

Doubly Linked List Operations
* insertNode(NodePtr Head, int item)
//add new node to ordered doubly linked list
* deleteNode(NodePtr Head, int item)
//remove a node from doubly linked list
* searchNode(NodePtr Head, int item)
* print(NodePtr Head, int item)

NodePtr searchNode(NodePtr Head, int item){
NodePtr Cur = Head->next;
while(Cur != Head){
if(Cur->data == item)
return Cur;
if(Cur->data < item)
Cur = Cur->next;
else
break;
}
return NULL;
}
Searching a node:

void print(NodePtr Head){
NodePtr Cur=Head->next;
while(Cur != Head){
cout << Cur->data << " ";
Cur = Cur->next;
}
cout << endl;
}
Print the whole circular list:

Circular Linked List
• Circular Linked List is a variation of Linked list in which the first
element points to the last element and the last element points to the
first element.
• Both Singly Linked List and Doubly Linked List can be made into a
circular linked list.
• In doubly linked list, the next pointer of the last node points to the
first node and the previous pointer of the first node points to the last
node making the circular in both directions.
162

Operations on Circular Linked List
2. Updation
3. Inserting
1. In empty list
2. In front of list
4. At the end
4. Deleting
1. First Node
2. Middle node
3. Last node
163

Operations on Circular Linked List
2. Updation
3. Inserting
1. In empty list
2. In front of list
4. At the end
4. Deleting
1. First Node
2. Middle node
3. Last node
164

• Linked list is a dynamic data structure so it can grow and shrink at
runtime by allocating and deallocating memory. So there is no need
to give initial size of linked list.
• Insertion and deletion of nodes are really easier. Unlike array here we
don’t have to shift elements after insertion or deletion of an element.
In linked list we just have to update the address present in next
pointer of a node.
165

• As size of linked list can increase or decrease at run time so there is
no memory wastage. In case of array there is lot of memory wastage,
like if we declare an array of size 10 and store only 6 elements in it
then space of 4 elements are wasted. There is no such problem in
linked list as memory is allocated only when required.
166

• More memory is required to store elements in linked list as compared
to array. Because in linked list each node contains a pointer and it
requires extra memory for itself.
• Elements or nodes traversal is difficult in linked list. We can not
randomly access any element as we do in array by index. For example
if we want to access a node at position n then we have to traverse all
the nodes before it. So, time required to access a node is large.
167

• In linked list reverse traversing is really difficult. In case of doubly
linked list its easier but extra memory is required for back pointer
hence wastage of memory.
168

Practice Question
•Suppose, we want a linked list such that whenever we
insert a value, it is inserted in a position such that it is
greater than or equal to the value of previous node
but less than the value of the next node. Such a
linked-list is called an Ordered Linked List. Write an
algorithm for its insert procedure.
169

2. Linked Lists.data.structure.algorithm.pdf

More Related Content

Similar to 2. Linked Lists.data.structure.algorithm.pdf

Recently uploaded

2. Linked Lists.data.structure.algorithm.pdf