Linked List

XHeader

35 20 4000

1000 2000 3000

2000 3000 55 X

4000

ptr ptr ptr

Question: Search a value 40 in the linked list.

Steps:

ptr = Header->Link

While(ptr != NULL) AND (ptr->Data != 40), do

ptrNULL

EndWhile

ptr = ptr->Link

Steps: (cntd)

If(ptr->Data == 40)

print “Search successful.”

print “Search unsuccessful.”Else

EndIf

Stop

1000

Circular Linked List

While(ptr != Header)

[Null Link Problem]ptr

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 ListAlgorithm: InsertFront_CL, X = 10

NULL

Header

20 30 1000

10

1000 2000 3000

new

4000

2000 30004000

2000

ptr

Circular Linked ListAlgorithm: InsertEnd_CL, X = 10

NULL

Header

20 30 100010

1000 2000 3000

new

40002000 30001000

4000

ptrptr

ptr

Circular Linked ListAlgorithm: Merge_CL

XHeader1

35 25 4000

1000 2000 3000

2000 3000 55

40001000

X

Header215 5 5000

8000 7000 6000

7000 6000 65 8000

5000

ptr

ptr1

7000

ptr1 ptr1

2000

Header

Linked List

XHeader

35 25 4000

1000 2000 3000

2000 3000 55

4000NULL

X

Header35 25 4000

1000 2000 3000

2000 3000 55 1000

4000

Single Linked List

Circular Linked List / Circular Single Linked List

Null Link Problem: Yes 2-way traversal: No

Null Link Problem: No 2-way traversal: Yes(Only virtual)

NodeStructure DATA

LINK

DATA

RLINKLLINK

NextPreviousNext

Linked ListNode Structure

DATA

RLINKLLINK

NextPrevious

X X 5000

1000

1000 40 7000

5000

5000 60 X

7000

Header

Double Linked List / Doubly Linked List

Left to Right

Right to Left

Traversal?

Algorithm: InsertFront_DL

X X 5000

1000

1000 15 7000

5000

5000 25 X

7000

Header

Question: Insert a node At the front. Value = 35

1000 35 5000

9000

new

90009000

ptr

Steps:

new = GetNode(NODE)

If(new == NULL), then

Else

print “Memory Insufficient.”

ptr = Header->RLink

new->Data = 35new->LLink = Headernew->RLink = ptr

Header->RLink = newptr->LLink = new

EndIf

Steps: (cntd)

X

Trace Algorithm: InsertFront_DL, X = 35

X X X

1000

Headerptr

Steps:new = GetNode(NODE)If(new == NULL), then

Elseprint “Memory Insufficient.”

ptr = Header->RLink

new->Data = Xnew->LLink = Headernew->RLink = ptr

Header->RLink = new

ptr->LLink = new

EndIfStop

NULL

If(ptr != NULL), then

EndIf

1000 35 X

2000

new

2000

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_DLSteps:

new = GetNode(NODE)

If(new == NULL), thenprint “Memory Insufficient.”

Elseptr = Header->RLink

new->Data = Xnew->LLink = Headernew->RLink = ptr

Header->RLink = newIf(ptr != NULL), then

ptr->LLink = newEndIf

EndIfStop

Algorithm: InsertEnd_DL

X X 5000

1000

1000 15 7000

5000

5000 25 X

7000

Header

Question: Insert a node At the end. Value = 35

7000 35 X

9000

new

9000

ptr

Steps:new = GetNode(NODE)If(new == NULL), then

Else

print “Memory Insufficient.”

new->Data = 35new->LLink = ptrnew->RLink = NULL

ptr->RLink = new

EndIf

Steps: (cntd)

X

ptr

While(ptr->RLink != NULL)

EndWhile

ptr = ptr->RLink

//new->RLink = ptr->RLink

Stop

ptr

ptr = Header

new->LLink = ptr

Trace Algorithm: InsertEnd_DL, X = 35

X X X1000

Header

Steps:new = GetNode(NODE)

1000 35 X

2000

new

2000

ptr

If(new == NULL), then

Else

print “Memory Insufficient.”

new->Data = X

new->RLink = NULL

ptr->RLink = new

EndIf

While(ptr->RLink != NULL)

EndWhile

ptr = ptr->RLink

//new->RLink = ptr->RLink

Stop

ptr = Header

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_DLSteps:

new = GetNode(NODE)

If(new == NULL), thenprint “Memory Insufficient.”

Elseptr = HeaderWhile(ptr->RLink != NULL)

ptr = ptr->RLinkEndWhile

new->Data = Xnew->LLink = ptrnew->RLink = NULL //new->RLink = ptr->RLink

ptr->RLink = newEndIf

Stop

Algorithm: InsertAny_DLQuestion: Insert a node. After node with value 25. Value = 35

X X 3000

1000

1000 45 5000

3000

3000 25 7000

5000

Header9000

ptr ptrptr

5000 15 X

7000

9000

ptr1

5000 35 7000

9000

new

X X 3000

1000

1000 45 5000

3000

3000 55 7000

5000

Header ptr ptrptr

5000 15 X

7000

ptr

Algorithm: InsertAny_DLQuestion: Insert a node.

After node with value 25.Value = 35

Steps:

ptr = HeaderWhile(ptr->RLink != NULL) AND (ptr->Data != 25)

EndWhileptr = ptr->RLink

new = GetNode(NODE)

If(new == NULL), thenprint “Memory Insufficient.”

Else

If(ptr->Data != 25), thenprint “25 not found in the linked list.”

Elseptr1 = ptr->RLinknew->Data = 35new->LLink = ptrnew->RLink = ptr1

EndIfEndIf

ptr->RLink = newptr1->LLink = new

Stop

XKEY

X X 3000

1000

1000 45 5000

3000

3000 25 X

5000

Header7000

ptr ptrptr

5000 35 X

7000

newTrace Algorithm: InsertAny_DLQuestion: Insert a node. KEY = 25. X = 35

Steps:

ptr = HeaderWhile(ptr->RLink != NULL)

AND (ptr->Data != KEY)

EndWhile

ptr = ptr->RLink

new = GetNode(NODE)

If(new == NULL), thenprint “Memory Insufficient.”

Else

If(ptr->Data != KEY), thenprint “KEY not found in the linked list.”

Elseptr1 = ptr->RLinknew->Data = Xnew->LLink = ptrnew->RLink = ptr1

EndIfEndIf

ptr->RLink = new

ptr1->LLink = new

Stop

Steps: (cntd)

If(ptr1 != NULL)

EndIf

ptr1NULL

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.

Algorithm: InsertAny_DLSteps:new = GetNode(NODE)If(new == NULL), then

print “Memory Insufficient.”Else

ptr = HeaderWhile(ptr->RLink != NULL) AND (ptr->Data != KEY)

ptr = ptr->RLinkEndWhileIf(ptr->Data != KEY), then

print “KEY not found in the linked list.”Else

ptr1 = ptr->RLinknew->Data = Xnew->LLink = ptrnew->RLink = ptr1ptr->RLink = newIf(ptr1 != NULL)

ptr1->LLink = new EndIf

EndIfEndIf

Algorithm: DeleteFront_DLQuestion: Delete a node. From the front of linked list.

X X 3000

1000

1000 45 5000

3000

3000 25 7000

5000

Header5000

ptr ptr1

5000 15 X

70001000

X X X

1000

Header Steps:If(Header->RLink == NULL)

print “Empty Linked List. Deletion not possible.”Else

ptr = Header->RLinkptr1 = ptr->RLinkHeader->RLink = ptr1ptr1->LLink = HeaderReturnNode(ptr)

EndIf

Trace Algorithm: DeleteFront_DLQuestion: Delete a node. From the front of linked list.

X X 3000

1000

1000 45 X

3000

HeaderX

ptr

Steps:

If(Header->RLink == NULL)

print “Empty Linked List. Deletion not possible.”

Else

ptr = Header->RLinkptr1 = ptr->RLink

Header->RLink = ptr1

ptr1->LLink = Header

ReturnNode(ptr)EndIfStop

If(ptr1 != NULL)

EndIf

ptr1NULL

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_DLSteps:

If(Header->RLink == NULL)print “Empty Linked List. Deletion not possible.”

Elseptr = Header->RLinkptr1 = ptr->RLink

Header->RLink = ptr1If(ptr1 != NULL)

ptr1->LLink = Header EndIf

ReturnNode(ptr)EndIfStop

Algorithm: DeleteEnd_DLQuestion: Delete a node. From the end of linked list.

X X 3000

1000

1000 45 5000

3000

3000 25 7000

5000

Header ptr ptr

5000 15 X

7000

X X X

1000

HeaderSteps:If(Header->RLink == NULL)

print “Empty Linked List. Deletion not possible.”Else

ptr1 = ptr->LLinkptr1->RLink = NULLReturnNode(ptr)

EndIf

ptrptr1

While(ptr->RLink != NULL)

EndWhileptr = ptr->RLink

X

ptr

ptr = Header

// ptr1->RLink = ptr->RLink

Algorithm: DeleteEnd_DLQuestion: Delete a node. From the end of linked list.

X X 3000

1000

1000 45 XHeader ptr

Steps:

If(Header->RLink == NULL)

print “Empty Linked List. Deletion not possible.”Else

ptr1 = ptr->LLink

ptr1->RLink = NULL

ReturnNode(ptr)EndIf

ptr1

While(ptr->RLink != NULL)

EndWhile

ptr = ptr->RLink X

ptrptr = Header

// ptr1->RLink = ptr->RLink

Stop

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_DLSteps:

If(Header->RLink == NULL)print “Empty Linked List. Deletion not possible.”

Elseptr = HeaderWhile(ptr->RLink != NULL)

ptr = ptr->RLinkEndWhile

ptr1 = ptr->LLinkptr1->RLink = NULL //ptr1->RLink = ptr->RLinkReturnNode(ptr)

EndIfStop

Algorithm: DeleteAny_DLQuestion: Delete a node. Value = 25

X X 3000

1000

1000 45 5000

3000

3000 25 7000

5000

Header ptr ptr

5000 15 9000

7000

ptr1

7000

ptr

7000 35 X

9000

3000

ptr2

X X 3000

1000

1000 45 5000

3000

3000 15 7000

5000

Header ptr ptr5000 35 X

7000

ptrptr

X X X

1000

Header

Algorithm: DeleteAny_DLQuestion: Delete a node. Value = 25

Steps:ptr = Header

While(ptr->RLink != NULL) AND (ptr->Data != 25)ptr = ptr->RLink

EndWhile

If(ptr->Data != 25)

ptr1 = ptr->LLinkptr2 = ptr->RLinkptr1->RLink = ptr2ptr2->LLink = ptr1

ReturnNode(ptr)

Elseprint “25 not found. Deletion not possible.”

EndIfStop

KEY

Trace Algorithm: DeleteAny_DLKEY = 25

Steps:ptr = Header

While(ptr->RLink != NULL) AND (ptr->Data != KEY)

ptr = ptr->RLink

EndWhile

If(ptr->Data != KEY)

ptr1 = ptr->LLinkptr2 = ptr->RLinkptr1->RLink = ptr2

ptr2->LLink = ptr1

ReturnNode(ptr)

Else

print “KEY not found. Deletion not possible.” EndIf

Stop

Steps: (cntd)

If(ptr2 != NULL)

EndIf

X X 3000

1000

1000 45 5000

3000

3000 25 X

5000

Header ptr ptrptr

ptr2NULL

ptr1

X

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.

Algorithm: DeleteAny_DLSteps:

ptr = HeaderWhile(ptr->RLink != NULL) AND (ptr->Data != KEY)

ptr = ptr->RLinkEndWhile

If(ptr->Data != KEY)print “KEY not found. Deletion not possible.”

Elseptr1 = ptr->LLinkptr2 = ptr->RLink

ptr1->RLink = ptr2If(ptr2 != NULL),

ptr2->LLink = ptr1EndIfReturnNode(ptr)

EndIfStop

Algorithm: Merge_DLQuestion: Merge 2 linked lists into a single double linked list.

X X 2000

1000

1000 15 3000

2000

2000 35 X

3000

Header1 ptr ptrptr

8000

X X 8000

7000

7000 25 9000

8000

8000 45 X

9000

Header2 ptr1

3000

Steps:ptr = Header1While(ptr->RLink != NULL)

EndWhile

ptr = ptr->RLink

ptr1 = Header2->RLink

Steps: (cntd)ptr->RLink = ptr1ptr1->LLink = ptr

Stop

Header

ReturnNode(Header2)Header = Header1

Needs to beconditional.

Trace Algorithm: Merge_DL

Steps:ptr = Header1

While(ptr->RLink != NULL)

EndWhile

ptr = ptr->RLink

ptr1 = Header2->RLink

ptr->RLink = ptr1

ptr1->LLink = ptr

Stop

ReturnNode(Header2)

Header = Header1

If(ptr1 != NULL)

EndIf

X X X

1000

Header1ptr

X X X

2000

Header2

Header

ptr1NULL

X X 2000

1000

Header1ptr

X X X

3000

Header2

Header

ptr1NULL

1000 15 X

2000

ptr

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_DLSteps:

ptr = Header1While(ptr->RLink != NULL)

ptr = ptr->RLinkEndWhile

ptr1 = Header2->RLink

ptr->RLink = ptr1If(ptr1 != NULL)

ptr1->LLink = ptrEndIf

ReturnNode(Header2)Header = Header1Stop

Algorithm: Split_DLQuestion: Split a list into 2 separate lists.

X X 2000

1000

1000 15 3000

2000

2000 35 4000

3000

Header ptr ptrptr

3000 25 5000

4000

4000 45 X

5000

ptr1

From value = 35

X X 4000

6000

Header1

X X 2000

1000

1000 15 3000

2000

2000 45 4000

3000

Header

3000 25 X

4000

ptrptr ptr ptr

X

6000

Algorithm: Split_DLQuestion: Split a list into 2 separate lists. From value = 35Steps:ptr = HeaderWhile(ptr->RLink != NULL) AND (ptr->Data != 35)

EndWhile

ptr = ptr->RLink

If(ptr->Data == 35)Header1 = GetNode(NODE)ptr1 = ptr->RLink

Header1->Data = NULLHeader1->LLink = NULLHeader1->RLink = ptr1

ptr->RLink = NULLptr1->LLink = Header1

Elseprint “35 not found. Split not possible.”

EndIf

KEY

Needs to be conditional.

Trace Algorithm: Split_DL, KEY = 35Steps:ptr = HeaderWhile(ptr->RLink != NULL) AND (ptr->Data != KEY)

EndWhile

ptr = ptr->RLink

If(ptr->Data == KEY)Header1 = GetNode(NODE)ptr1 = ptr->RLink

Header1->Data = NULLHeader1->LLink = NULLHeader1->RLink = ptr1

ptr->RLink = NULL

ptr1->LLink = Header1

Elseprint “KEY not found. Split not possible.”

EndIf

If(ptr! != NULL)

EndIf

X X 2000

1000

1000 35 X

2000

Headerptr

ptr

ptr1NULL

X X X

3000

Header1

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.

Algorithm: Split_DLSteps:

ptr = HeaderWhile(ptr->RLink != NULL) AND (ptr->Data != KEY)

ptr = ptr->RLinkEndWhile

If(ptr->Data == KEY)Header1 = GetNode(NODE)ptr1 = ptr->RLink

Header1->Data = NULLHeader1->LLink = NULLHeader1->RLink = ptr1

ptr->RLink = NULLIf(ptr1 != NULL)

ptr1->LLink = Header1EndIf

Elseprint “KEY not found. Split not possible.”

EndIfStop

Linked List

Double Linked List

X X 2000 1000 15 3000 2000 45 X

Header

1000 2000 3000

CircularCircular Doubly Linked List

Null Link Problem: Yes

10003000

Applications of Linked List

5x2y2 + 3x2y - 20y - 100

Polynomial in 2 variables

Co-efficient

Node Structure: Coefficient Power of x Power of y LinkNext Node

X X X 5 2 2 3 2 1

-20 0 1 -100 0 0 X

Header

Representation of Polynomials

Applications of Linked List

10x4y3 + 5xy - 50

Polynomial in 2 variables

X X X 10 4 3

5 1 1 -50 0 0 X

Header

Representation of Polynomials

Applications of Linked List

P(x) = 20x3 - 15x2 - 50x + 100

Polynomial in 1 variable

Representation of Polynomials

Node Structure: Coefficient Power of x LinkNext Node

Node Structure: Coefficient Power of x Power of y Link

Next Node

Power of z

P(x,y,z) = 10x3y2z + 5xy2z2 + .......

Polynomial in 3 variables