the linked list (ll)
DESCRIPTION
The Linked List (LL). Each node x in a linked list contains:. key [ x ] - The value stored at x. next [ x ] - Pointer to left child of x. The while list is accessed by a head pointer to the first node. Last one points to NIL. head. Key(x). next [ x ]. - PowerPoint PPT PresentationTRANSCRIPT
![Page 1: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/1.jpg)
The Linked List (LL) Each node x in a linked list contains:
Key(x)
head
key[x]- The value stored at x. next[x]- Pointer to left child of x. The while list is accessed by a head
pointer to the first node. Last one points to NIL
next[x]
![Page 2: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/2.jpg)
Inserting the element into LL Find a place for it. Point “new’s” next to the next. Point “previous’s”next to new.
Key(x)
head
next[x]
Key(x)
next[x]
Key(x)
next[x]
Key(x)
next[x]
New element Key(x)
next[x]
Key(x)
next[x]
head head
![Page 3: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/3.jpg)
Removing the element from LL Find the element. Point “previous’s” next to the next. Point previous to new.
head
Key(x)
next[x]
Key(x)
next[x]
Key(x)
next[x]
Key(x)
next[x]
Deleted elementKey(x)
next[x]
Key(x)
next[x]
head head
![Page 4: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/4.jpg)
Reporting in sorted order
If you keep the list sorted at all the times the reporting it in sorted order is as simple as iterating through the list and reporting the elements as you encounter them.
![Page 5: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/5.jpg)
Heap
A heap is a binary tree storing keys, with the following properties: partial order:
key (child) < key(parent) left-filled levels:
the last level is left-filled the other levels are full
X
T O
G S M N
A E R B I
![Page 6: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/6.jpg)
Heap RepresentationsX
T O
G S M N
A E R B I
1
32
8
4
9
5
10 11 12
X T O G S M N A E R B I1 2 3 4 5 6 7 8 9 10 11 12
6 7
• left_child(i)= 2i• right_child(i) = 2i+1• parent(j) = j div 2
![Page 7: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/7.jpg)
Heap Insertion
X
T O
G S M N
A E R B I
X
T O
G S M N
A E R B I
P
P
X
T O
G S P N
A E R B I M
•Add the key in the next available spot in the heap.
•Upheap checks if the new node is greater than its parent. If so, it switches the two.
•Upheap continues up the tree
![Page 8: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/8.jpg)
Heap Insertion
X
T O
G S P N
A E R B I M
X
T P
G S O N
A E R B I M
![Page 9: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/9.jpg)
Heap Insertion
Upheap terminates when new key is less than the key of its parent or the top of the heap is reached.
(total #switches) <= (height of tree- 1) =log n
X
T P
G S O N
A E R B I M
![Page 10: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/10.jpg)
Heapify Algorithm Assumes L and R sub-trees of i are already Heaps and makes It's sub-
tree a Heap:Heapify(A,i,n)
If (2i<=n) & (A[2i]>A[i]) Then largest=2iElse largest=iIf (2i+1<=n) & (A[2i+1]>A[largest]) Then largest=2i+1If (largest != i) Then Exchange (A[i],A[largest]) Heapify(A,largest,n)
EndifEnd Heapify
![Page 11: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/11.jpg)
Extracting the Maximum from a Heap:
Here is the algorithm:Heap-Extract-Max(A)
Remove A[1]A[1]=A[n]n=n-1Heapify(a,1,n)
End Heap-Extract-Max
X
T P
G S O N
A E R B I MM
T P
G S O N
A E R B I
1
2
3
![Page 12: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/12.jpg)
Building a Heap Builds a heap from an unsorted array:Build_Heap(A,n)
For i=floor(n/2) down to 1 doHeapify(A,i,n)
End Build_Heap Example:
4 1 3 2 16
9 10
14
8 7A4
1 3
2 16 9 10
14 8 7
i
![Page 13: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/13.jpg)
Building a Heap (cont’d.)4
1 3
2 16 9 10
14 8 7
i
4
1 3
14 16 9 10
2 8 7
i
4
1
3
2
16 9
10
14
8 7
i
4
1
3
2
16
9
10
14
8
7
i
![Page 14: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/14.jpg)
Building a Heap (cont’d.)
4 1
3
2
16
9
1014
8 7
![Page 15: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/15.jpg)
Finding an Element Must look at each element of the array:For i=1 to n do
if A(i) == bbreak;
Example:
A X T O G S M N A E R B I1 2 3 4 5 6 7 8 9 10 11 12
X
T O
G S M N
A E R B I
1
32
8
4
9
5
10 11 12
6 7
![Page 16: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/16.jpg)
Removing an Element Must find it first After that similar to remove MaxRemove A[i]
A[i]=A[n]n=n-1Heapify(a,i,n)
A X T O G S M N A E R B I1 2 3 4 5 6 7 8 9 10 11 12
X
T O
G S M N
A E R B I
1
32
8
4
9
5
10 11 12
6 7
![Page 17: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/17.jpg)
Removing an ElementX
T O
G S M N
A E R B I
1
32
8
4
9
5
10 11 12
6 7
X
T O
G I M N
A E R B
1
32
8
4
9
5
10 11
6 7
X
T O
G R M N
A E I B
1
32
8
4
9
5
10 11
6 7
![Page 18: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/18.jpg)
The Binary Search Tree (BST) Each node x in a binary search tree (BST)
contains:
P(x)
Key(x)
x
key[x]- The value stored at x. left[x]- Pointer to left child of x. right[x]- Pointer to right child of x. p[x]- Pointer to parent of x.left[x] right[x]
![Page 19: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/19.jpg)
BST- Property
Keys in BST satisfy the following properties: Let x be a node in a BST: If y is in the left subtree of x then:
key[y]<=key[x] If y is in the right subtree of x then:
key[y]>key[x]
![Page 20: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/20.jpg)
Example:
• Two valid BST’s for the keys: 2,3,5,5,7,8.
5
3 7
82 5
2
3
7
5 8
5
![Page 21: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/21.jpg)
In-Order Tree walk
Can print keys in BST with in-order tree walk.
Key of each node printed between keys in left and those in right subtrees.
Prints elements in monotonically increasing order.
Running time?
![Page 22: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/22.jpg)
In-Order Traversal
Inorder-Tree-Walk(x)1: If x!=NIL then2: Inorder-Tree-Walk(left[x]) 3: Print(key[x])4: Inorder-Tree-Walk(right[x])
What is the recurrence for T(n)?What is the running time?
![Page 23: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/23.jpg)
In-Order Traversal
In-Order traversal can be thought of as a projection of BST nodes on an interval.
At most 2d nodes at level d=0,1,2,…
5
3 7
82 5
2 3 5 5 7 8
![Page 24: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/24.jpg)
Other Tree Walks
Preorder-Tree-Walk(x)1: If x!=NIL then2: Print(key[x])3: Preorder-Tree-Walk(left[x]) 4: Preorder-Tree-Walk(right[x])
Postorder-Tree-Walk(x)1: If x!=NIL then2: Postorder-Tree-Walk(left[x]) 3: Postorder-Tree-Walk(right[x]) 4: Print(key[x])
![Page 25: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/25.jpg)
Searching in BST: To find element with key k in tree T:
Compare k with the root If k<key [root[T ]] search for k in the left sub-
tree Otherwise, search for k in the right sub-tree
Search(T,k)1: x=root[T]2: If x=NIL then return(“not found”)
3: If k=key[x] then return(“found the key”) 4: If k< key[x] then Search(left[x],k)
5: else Search(right[x],k)
![Page 26: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/26.jpg)
Examples:
Search(T,11)5
3 10
112 5
4
7
Search(T,6)
5
3 10
112 5
4
7
![Page 27: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/27.jpg)
BST Insertion
Basic idea: similar to search. BST-Insert:
Take an element z (whose right and left children are NIL) and insert it into T.
Find a place where z belongs, using code similar to that of Search.
Add z there.
![Page 28: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/28.jpg)
Insert KeyBST-Insert(T,z)1: y=NIL2: x=root[T]3: While x!=NIL do4: y=x;5: if key[z]<key[x] then6: x=left[x]7: else x=right[x]8: p[z]=y9: if y=NIL the root[T]=z 10: else if key[z]<key[y] then left[y]=z 11: else right[y]=z
5
3 10
112 5
4
7
Insert(T,8)
8
![Page 29: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/29.jpg)
Locating the Minimum
BST-Minimum(T)1: x=root[T]2: While left[x]!=NIL do3: x=left[x] 4: return x
5
3 10
112 5
4
7
8
![Page 30: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/30.jpg)
Application: Sorting Can use BST-Insert and Inorder-Tree-Walk
to sort list of n numbersBST-Sort1: root[T]=NIL2: for i=1to n do3: BST-Insert(T,A[i])4: Inorder-Tree-Walk(T)
5
3 10
5
4
7
8
55
10
Sort Input: 5, 10, 3, 5, 7, 5, 4, 8
Inorder Walk: 3, 4, 5, 5, 7, 8, 10
![Page 31: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/31.jpg)
SuccessorGiven x, find node with smallest key greater
than key[x]. Here are two cases depending on rightsubtree of x. Successor Case 1:
The right subtree of x is not empty. Successor is leftmost node in right subtree. That is, we must return BST-Minimum(right[x])
5
3 10
5
4
7
8
x
Successor
![Page 32: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/32.jpg)
Successor Successor Case 2: The right subtree of x is empty. Successor is
lowest ancestor of x. Observe that, “Successor” is defined as the element encountered by inorder traversal.
5
1 10
3 7
8x
Successor BST-Successor(x)1: If right[x]!=NIL then2: return BST-Minimum(right[x])3: y=p[x] 4: While (y!=NIL) and (x=right[y])5: x=y6: y=p[y]7: return yRunning time?
![Page 33: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/33.jpg)
Deletion
Delete a node x from tree T: Case 1: x has no children.
A
B D
C
x
A
B D
![Page 34: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/34.jpg)
Deletion:
Case 2: x has one child (call it y). Make p[x] to replace y instead of x as its child, and make p[x] to be p[y].
A
B D
Cx
A
DC
![Page 35: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/35.jpg)
Deletion:
Case 3: x has two children: Find its successor ( or predecessor) y. Remove y. (Note y has at most one child, why?) Replace x by y.
A
B D
C
x C
DB
y
![Page 36: The Linked List (LL)](https://reader031.vdocuments.mx/reader031/viewer/2022020118/5681406f550346895dabf07b/html5/thumbnails/36.jpg)
Delete ProcedureBSFT-Delete(T, z)1: If (left[z]=NIL) or (right[z]=NIL) then2: y=z3: else y=BST-Successor(z) 4: If left[y]!=NIL then5: x=left[y]6: else x=right[y]7: If x!=NIL then p[x]=p[y]8: If p[y]=NIL then root[T]=x9: else if y=left[p[y]] then left[p[y]]=x10: else right[p[y]]=x11: if y!=z then key[z]=key[y]12: return y