Transcript DFS_5_Linked-List

Linked List
Question: Search a value 40 in the linked list.
ptr
Header
X
2000
1000
Circular Linked List
ptr
ptr
35
3000
2000
20
4000
3000
[Null Link Problem]
ptr
ptr
55
1000
X
NULL
4000
Steps:
Steps: (cntd)
ptr = Header->Link
If(ptr->Data == 40)
NULL)
While(ptr != Header)
AND (ptr->Data != 40), do
print “Search successful.”
Else
ptr = ptr->Link
EndWhile
print “Search unsuccessful.”
EndIf
Stop
Linked List
•Circular Linked List:
–Advantages:
•Virtual traversal possible in both the directions.
–Left to Right (Direct)
–Right to Left (Indirect)
•Overcomes the NULL Link problem.
Circular Linked List
Algorithm: InsertFront_CL, X = 10
new
10
2000
4000
Header
NULL
4000
2000
1000
ptr
20
3000
2000
30
1000
3000
Circular Linked List
Algorithm: InsertEnd_CL, X = 10
new
ptr
Header
NULL
2000
1000
ptr
ptr
20
3000
2000
30
10
4000
1000
3000
1000
4000
Circular Linked List
Algorithm: Merge_CL
Header
ptr
Header1
X
2000
7000
35
1000
Header2
X
7000
8000
15
3000
25
4000
55
1000
2000
3000
4000
ptr1
ptr1
ptr1
6000
7000
5
5000
6000
65
2000
8000
5000
Linked List
X
35
2000
2-way traversal: No
Single Linked List
Null Link Problem: Yes
Header
1000
3000
25
2000
3000
NULL
4000
Circular Linked List /
Circular Single Linked List
Null Link Problem: No
55
4000
2-way traversal: Yes
(Only virtual)
Header
X
2000
1000
Node
Structure
35
3000
2000
LINK
25
4000
1000
4000
3000
LLINK
DATA
55
RLINK
DATA
Next
Previous
Next
Linked List
Node Structure
LLINK
RLINK
DATA
Previous
Next
Traversal?
Left to Right
Header
X
X
1000
5000
1000 40 7000
5000 60
5000
Right to Left
Double Linked List / Doubly Linked List
7000
X
Algorithm: InsertFront_DL
Question: Insert a node
At the front.
Value = 35
X
new
1000 35 5000
9000
Header
ptr
X
9000 15 7000
1000
X
9000
5000
1000
5000
Steps:
new = GetNode(NODE)
If(new == NULL), then
print “Memory Insufficient.”
Else
5000 25
X
7000
Steps: (cntd)
ptr = Header->RLink
new->Data = 35
new->LLink = Header
new->RLink = ptr
Header->RLink = new
ptr->LLink = new
EndIf
Trace Algorithm: InsertFront_DL, X = 35
Steps:
new = GetNode(NODE)
If(new == NULL), then
print “Memory Insufficient.”
Else
ptr = Header->RLink
new->Data = X
new->LLink = Header
new->RLink = ptr
Header->RLink = new
If(ptr != NULL), then
ptr->LLink = new
EndIf
EndIf
Stop
new
1000
35
X
2000
Header
X
X
1000
2000
X
ptr
NULL
Linked List
•Algorithm:
–InsertFront_DL
•Input:
–Header: Pointer to the starting node of the linked
list.
–X: Data of the node to be inserted at front.
•Output:
–Node with data X inserted at front of Double
Linked List.
•Data Structure:
–Double Linked List whose address of starting node
is known from Header.
Algorithm: InsertFront_DL
Steps:
new = GetNode(NODE)
If(new == NULL), then
print “Memory Insufficient.”
Else
ptr = Header->RLink
new->Data = X
new->LLink = Header
new->RLink = ptr
Header->RLink = new
If(ptr != NULL), then
ptr->LLink = new
EndIf
EndIf
Stop
Algorithm: InsertEnd_DL
Question: Insert a node
At the end.
Value = 35
X
new
7000 35
X
ptr
Header
ptr
ptr
X
1000 15 7000
5000 25 9000
X
5000
7000
5000
9000
1000
Steps:
new = GetNode(NODE)
If(new == NULL), then
print “Memory Insufficient.”
Else
ptr = Header
While(ptr->RLink != NULL)
ptr = ptr->RLink
EndWhile
X
Steps: (cntd)
new->Data = 35
new->LLink = ptr
new->RLink = NULL //new->RLink =
ptr->RLink
ptr->RLink = new
EndIf
Stop
Trace Algorithm: InsertEnd_DL, X = 35
Steps:
new = GetNode(NODE)
new
If(new == NULL), then
1000
print “Memory Insufficient.”
Else
ptr = Header
While(ptr->RLink != NULL)
ptr = ptr->RLink
EndWhile
ptr
Header
X
X
2000
X
1000
new->Data = X
new->LLink = ptr
new->RLink = NULL //new->RLink = ptr->RLink
ptr->RLink = new
EndIf
Stop
35
2000
X
Linked List
•Algorithm:
–InsertEnd_DL
•Input:
–Header: Pointer to the starting node of the linked
list.
–X: Data of the node to be inserted at end.
•Output:
–Node with data X inserted at end of Double Linked
List.
•Data Structure:
–Double Linked List whose address of starting node
is known from Header.
Algorithm: InsertEnd_DL
Steps:
new = GetNode(NODE)
If(new == NULL), then
print “Memory Insufficient.”
Else
ptr = Header
While(ptr->RLink != NULL)
ptr = ptr->RLink
EndWhile
new->Data = X
new->LLink = ptr
new->RLink = NULL //new->RLink = ptr->RLink
ptr->RLink = new
EndIf
Stop
Algorithm: InsertAny_DL
Question: Insert a node. After node with value 25. Value = 35
new
5000 35 7000
ptr
Header
X 3000
X
1000
ptr
Header
X 3000
X
1000
9000
ptr
ptr
ptr1
1000 45 5000
9000
3000 25 7000
9000 15
5000
3000
5000
7000
ptr
ptr
ptr
1000 45 5000
3000 55 7000
3000
5000
5000 15
7000
X
X
Steps:
Algorithm: InsertAny_DL
new = GetNode(NODE)
Question: Insert a node.
After node with value 25.
If(new == NULL), then
print “Memory Insufficient.”
X
Value = 35
Else
ptr = Header
While(ptr->RLink != NULL) AND (ptr->Data != 25)
ptr = ptr->RLink
EndWhile
If(ptr->Data != 25), then
print “25 not found in the linked list.”
Else
ptr1 = ptr->RLink
new->Data = 35
new->LLink = ptr
new->RLink = ptr1
ptr->RLink = new
ptr1->LLink = new
EndIf
EndIf
Stop
KEY
Trace Algorithm: InsertAny_DL
new
Question: Insert a node. KEY = 25. X = 35
ptr
Header
X 3000
X
1000
Steps:
5000 35
X
7000
ptr
ptr
1000 45 5000
3000 25 7000
X
3000
5000
ptr1
NULL
Steps: (cntd)
If(ptr->Data != KEY), then
new = GetNode(NODE)
print “KEY not found
If(new == NULL), then
in the linked list.”
print “Memory Insufficient.”
Else
ptr1 = ptr->RLink
Else
new->Data = X
ptr = Header
new->LLink = ptr
While(ptr->RLink != NULL)
new->RLink = ptr1
ptr->RLink = new
AND (ptr->Data != KEY)
If(ptr1 != NULL)
ptr = ptr->RLink
ptr1->LLink = new
EndWhile
EndIf
EndIf
EndIf
Stop
Linked List
•Algorithm:
–InsertAny_DL
•Input:
–Header: Pointer to the starting node of the linked
list.
–KEY: Data of the node after which a new node is to
be inserted.
–X: Data of the node to be inserted.
•Output:
–Node with data X inserted after node with data
KEY if successful, a message otherwise.
•Data Structure:
–Double Linked List whose address of starting node
is known from Header.
Steps:
Algorithm: InsertAny_DL
new = GetNode(NODE)
If(new == NULL), then
print “Memory Insufficient.”
Else
ptr = Header
While(ptr->RLink != NULL) AND (ptr->Data != KEY)
ptr = ptr->RLink
EndWhile
If(ptr->Data != KEY), then
print “KEY not found in the linked list.”
Else
ptr1 = ptr->RLink
new->Data = X
new->LLink = ptr
new->RLink = ptr1
ptr->RLink = new
If(ptr1 != NULL)
ptr1->LLink = new
EndIf
EndIf
EndIf
Algorithm: DeleteFront_DL
Question: Delete a node.
Header
X 5000
X
3000
1000
Header
X
X
X
1000
From the front of linked list.
ptr
ptr1
1000 45 5000
3000
1000 25 7000
3000
5000
5000 15
7000
Steps:
If(Header->RLink == NULL)
print “Empty Linked List. Deletion not possible.”
Else
ptr = Header->RLink
ptr1 = ptr->RLink
Header->RLink = ptr1
ptr1->LLink = Header
ReturnNode(ptr)
EndIf
X
Trace Algorithm: DeleteFront_DL
Question: Delete a node.
From the front of linked list.
Steps:
If(Header->RLink == NULL)
print “Empty Linked List. Deletion not possible.”
Else
ptr = Header->RLink
ptr1 = ptr->RLink
Header->RLink = ptr1
If(ptr1 != NULL)
ptr1->LLink = Header
EndIf
ReturnNode(ptr)
EndIf
Stop
Header
X 3000
X
X
1000
ptr
1000 45
3000
X
ptr1
NULL
Linked List
•Algorithm:
–DeleteFront_DL
•Input:
–Header: Pointer to the starting node of the
linked list.
•Output:
–Node from the front deleted from the linked
list if it exists, a message otherwise.
•Data Structure:
–Double Linked List whose address of
starting node is known from Header.
Algorithm: DeleteFront_DL
Steps:
If(Header->RLink == NULL)
print “Empty Linked List. Deletion not possible.”
Else
ptr = Header->RLink
ptr1 = ptr->RLink
Header->RLink = ptr1
If(ptr1 != NULL)
ptr1->LLink = Header
EndIf
ReturnNode(ptr)
EndIf
Stop
Algorithm: DeleteEnd_DL
Question: Delete a node.
ptr
Header
X 3000
X
1000
Header
X
X
X
1000
ptr
From the end of linked list.
ptr1
ptr
1000 45 5000
3000 25 7000
X
3000
5000
ptr
5000 15
7000
Steps:
If(Header->RLink == NULL)
print “Empty Linked List. Deletion not possible.”
Else
ptr = Header
While(ptr->RLink != NULL)
ptr = ptr->RLink
EndWhile
ptr1 = ptr->LLink
ptr1->RLink = NULL // ptr1->RLink = ptr->RLink
ReturnNode(ptr)
EndIf
X
Algorithm: DeleteEnd_DL
Question: Delete a node.
From the end of linked list.
Steps:
If(Header->RLink == NULL)
print “Empty Linked List. Deletion not possible.”
Else
ptr1
ptr = Header
ptr
While(ptr->RLink != NULL)
Header
X 3000
X
ptr = ptr->RLink
X
EndWhile
1000
ptr1 = ptr->LLink
ptr1->RLink = NULL // ptr1->RLink = ptr->RLink
ReturnNode(ptr)
EndIf
Stop
ptr
1000 45
X
Linked List
•Algorithm:
–DeleteEnd_DL
•Input:
–Header: Pointer to the starting node of the
linked list.
•Output:
–Node from the end deleted from the linked
list if it exists, a message otherwise.
•Data Structure:
–Double Linked List whose address of
starting node is known from Header.
Algorithm: DeleteEnd_DL
Steps:
If(Header->RLink == NULL)
print “Empty Linked List. Deletion not possible.”
Else
ptr = Header
While(ptr->RLink != NULL)
ptr = ptr->RLink
EndWhile
ptr1 = ptr->LLink
ptr1->RLink = NULL //ptr1->RLink = ptr->RLink
ReturnNode(ptr)
EndIf
Stop
Algorithm: DeleteAny_DL
Question: Delete a node.
ptr
Header
X 3000
X
1000
Value = 25
ptr1
ptr
ptr
ptr2
7000
1000 45 5000
3000 25 7000
5000
3000 15 9000
3000
5000
7000
7000 35
X
9000
ptr
Header
X 3000
X
1000
Header
X
X
X
1000
ptr
ptr
1000 45 5000
3000 15 7000
3000
5000
ptr
5000 35
7000
X
Algorithm: DeleteAny_DL
Question: Delete a node.
Value = 25
Steps:
ptr = Header
While(ptr->RLink != NULL) AND (ptr->Data != 25)
ptr = ptr->RLink
EndWhile
If(ptr->Data != 25)
print “25 not found. Deletion not possible.”
Else
ptr1 = ptr->LLink
ptr2 = ptr->RLink
ptr1->RLink = ptr2
ptr2->LLink = ptr1
ReturnNode(ptr)
EndIf
Stop
KEY
Trace Algorithm: DeleteAny_DL
KEY = 25
ptr
Header
X 3000
X
1000
ptr1
ptr
1000 45 5000
X
ptr
3000 25
3000
Steps:
ptr = Header
While(ptr->RLink != NULL)
AND (ptr->Data != KEY)
ptr = ptr->RLink
5000
Steps: (cntd)
ptr1 = ptr->LLink
ptr2 = ptr->RLink
ptr1->RLink = ptr2
If(ptr2 != NULL)
ptr2->LLink = ptr1
EndIf
ReturnNode(ptr)
EndWhile
If(ptr->Data != KEY)
print “KEY not found.
Deletion not possible.”
Else
X
EndIf
Stop
ptr2
NULL
Linked List
•Algorithm:
–DeleteAny_DL
•Input:
–Header: Pointer to the starting node of the linked
list.
–KEY: Data of the node to be deleted.
•Output:
–Node with data KEY deleted if it exists, a message
otherwise.
•Data Structure:
–Double Linked List whose address of starting node
is known from Header.
Steps:
Algorithm: DeleteAny_DL
ptr = Header
While(ptr->RLink != NULL) AND (ptr->Data != KEY)
ptr = ptr->RLink
EndWhile
If(ptr->Data != KEY)
print “KEY not found. Deletion not possible.”
Else
ptr1 = ptr->LLink
ptr2 = ptr->RLink
ptr1->RLink = ptr2
If(ptr2 != NULL),
ptr2->LLink = ptr1
EndIf
ReturnNode(ptr)
EndIf
Stop
Algorithm: Merge_DL
Question: Merge 2 linked lists into a single double linked list.
Header
ptr
Header1
X 2000
X
1000
Header2
X 8000
X
7000
ptr
ptr
1000 15 3000
2000 35 8000
X
2000
3000
ptr1
3000 25 9000
7000
8000
Steps:
ptr = Header1
While(ptr->RLink != NULL)
ptr = ptr->RLink
EndWhile
ptr1 = Header2->RLink
8000 45
9000
Steps: (cntd)
ptr->RLink = ptr1
ptr1->LLink = ptr
X
Needs to be
conditional.
ReturnNode(Header2)
Header = Header1
Stop
Trace Algorithm:
Merge_DL
Steps:
ptr = Header1
While(ptr->RLink != NULL)
ptr = ptr->RLink
EndWhile
Header
ptr
Header1
X
X
X
1000
Header2
X
X
X
2000
ptr1
NULL
ptr1 = Header2->RLink
ptr->RLink = ptr1
If(ptr1 != NULL)
ptr1->LLink = ptr
EndIf
Header
ptr
Header1
X 2000
X
1000
ptr
1000 15
2000
ReturnNode(Header2)
Header = Header1
Stop
Header2
X
X
X
3000
ptr1
NULL
X
Linked List
•Algorithm:
–Merge_DL
•Input:
–Header1: Pointer to the starting node of the 1st
linked list.
–Header2: Pointer to the starting node of the 2nd
linked list.
•Output:
–Header: Pointer to the node of
merged/combined/joined linked list.
•Data Structure:
–Double Linked List whose address of starting node
is known from Header.
Algorithm: Merge_DL
Steps:
ptr = Header1
While(ptr->RLink != NULL)
ptr = ptr->RLink
EndWhile
ptr1 = Header2->RLink
ptr->RLink = ptr1
If(ptr1 != NULL)
ptr1->LLink = ptr
EndIf
ReturnNode(Header2)
Header = Header1
Stop
Algorithm: Split_DL
Question: Split a list into 2 separate lists. From value = 35
ptr
Header
X 2000
X
ptr
ptr
1000 15 3000
2000 35 4000
X
2000
3000
1000
Header1
X 4000
X
6000
ptr
Header
X 2000
X
1000
ptr1
3000
6000 25 5000
4000
ptr
ptr
1000 15 3000
2000 45 4000
2000
3000
4000 45
X
5000
ptr
3000 25
4000
X
Algorithm: Split_DL
Question: Split a list into 2 separate lists. From value = 35
Steps:
ptr = Header
While(ptr->RLink != NULL) AND (ptr->Data != 35)
ptr = ptr->RLink
EndWhile
If(ptr->Data == 35)
Header1 = GetNode(NODE)
ptr1 = ptr->RLink
Header1->Data = NULL
Header1->LLink = NULL
Header1->RLink = ptr1
ptr->RLink = NULL
ptr1->LLink = Header1
Else
EndIf
Needs to be conditional.
print “35 not found. Split not possible.”
KEY
Steps:
Trace Algorithm: Split_DL, KEY = 35
ptr = Header
While(ptr->RLink != NULL) AND (ptr->Data != KEY)
ptr = ptr->RLink
EndWhile
If(ptr->Data == KEY)
Header1 = GetNode(NODE)
ptr1 = ptr->RLink
Header1->Data = NULL
Header1->LLink = NULL
Header1->RLink = ptr1
ptr
Header
X 2000
X
1000
ptr->RLink = NULL
If(ptr! != NULL)
ptr1->LLink = Header1
EndIf
Else
print “KEY not found. Split not possible.”
EndIf
ptr
1000 35
X
2000
Header1
X
X
X
3000
ptr1
NULL
Linked List
•Algorithm:
–Split_DL
•Input:
–Header: Pointer to the starting node of the linked
list.
–KEY: Data of the node after which the list is
supposed to be split.
•Output:
–Header1: Pointer to the starting node of the 2nd
linked list if split is successful or message
otherwise.
•Data Structure:
–Double Linked List whose address of starting node
is known from Header.
Steps:
Algorithm: Split_DL
ptr = Header
While(ptr->RLink != NULL) AND (ptr->Data != KEY)
ptr = ptr->RLink
EndWhile
If(ptr->Data == KEY)
Header1 = GetNode(NODE)
ptr1 = ptr->RLink
Header1->Data = NULL
Header1->LLink = NULL
Header1->RLink = ptr1
ptr->RLink = NULL
If(ptr1 != NULL)
ptr1->LLink = Header1
EndIf
Else
print “KEY not found. Split not possible.”
EndIf
Stop
Linked List
Circular Double Linked List
Circular Doubly Linked List
Header
3000
X
X 2000
1000
1000 15 3000
2000 45 1000
X
2000
3000
Null Link Problem: Yes
Applications of Linked List
Representation of Polynomials
Polynomial in 2 variables
5x2y2 + 3x2y - 20y - 100
Co-efficient
Node Structure: Coefficient Power of x Power of y
Link
Next Node
Header
X
X
X
5
-20
0
1
2
2
-100
0
3
2
0
X
1
Applications of Linked List
Representation of Polynomials
Polynomial in 2 variables
10x4y3 + 5xy - 50
Header
X
X
X
10
5
4
1
3
1
-50
0
0
X
Applications of Linked List
Representation of Polynomials
Polynomial in 1 variable
P(x) = 20x3 - 15x2 - 50x + 100
Node Structure:
Coefficient Power of x
Link
Next Node
Polynomial in 3 variables
P(x,y,z) = 10x3y2z + 5xy2z2 + .......
Node Structure: Coefficient Power of x Power of y Power of z Link
Next
Node