§6 Leftist Heaps

1. Target : Speed up merging in O(N). CHAPTER 5 Graph Algorithms §6 Leftist Heaps  Heap: Structure Property + Order Property Discussion 5: How fast can we merge two heaps if we simply use the original heap structure? Leftist Heap: Order Property – the same Structure Property – binary tree, but unbalanced 1/10

2. §6 Leftist Heaps 【Definition】The null path length, Npl(X), of any node X is the length of the shortest path from X to a node without two children. Define Npl(NULL) = –1. Note: Npl(X) = min { Npl(C) + 1 for all C as children of X } 【Definition】The leftist heap property is that for every node X in the heap, the null path length of the left child is at least as large as that of the right child. 1 1 The tree is biased to get deep toward the left. 1 0 1 0   0 0 0 1 0 0 0 2/10

3. §6 Leftist Heaps 【Theorem】A leftist tree with r nodes on the right path must have at least 2r – 1 nodes. Proof: By induction on p. 162. Discussion 6: How long is the right path of a leftist tree of N nodes? What does this conclusion mean to us? Trouble makers:Insert and Merge Note:Insertion is merely a special case of merging. 3/10

4. §6 Leftist Heaps 6 6 12 12 7 7 18 18 24 24 8 8 37 37 33 33 17 17 18 18 26 26 3 3 6 10 10 8 12 7 21 14 21 14 17 18 24 37 18 23 23 26 33 H1 H2 Declaration: Step 1: Merge( H1->Right, H2 ) struct TreeNode { ElementType Element; PriorityQueue Left; PriorityQueue Right; int Npl; } ; Step 2: Attach( H2, H1->Right ) Merge (recursive version): Step 3: Swap(H1->Right, H1->Left ) if necessary 4/10

5. §6 Leftist Heaps PriorityQueue Merge ( PriorityQueue H1, PriorityQueue H2 ) { if ( H1 == NULL ) return H2; if ( H2 == NULL ) return H1; if ( H1->Element < H2->Element ) return Merge1( H1, H2 ); else return Merge1( H2, H1 ); } static PriorityQueue Merge1( PriorityQueue H1, PriorityQueue H2 ) { if ( H1->Left == NULL ) /* single node */ H1->Left = H2; /* H1->Right is already NULL and H1->Npl is already 0 */ else { H1->Right = Merge( H1->Right, H2 ); /* Step 1 & 2 */ if ( H1->Left->Npl < H1->Right->Npl ) SwapChildren( H1 ); /* Step 3 */ H1->Npl = H1->Right->Npl + 1; } /* end else */ return H1; } What if Npl is NOT updated? Tp = O(log N) 5/10

6. §6 Leftist Heaps 3 10 7 21 14 8 37 23 17 26 3 3 6 10 10 8 6 6 12 7 21 21 14 14 17 12 12 18 24 7 37 18 23 23 26 18 18 24 24 37 33 8 H1 33 33 H2 17 18 18 26 Merge (iterative version): Step 2:Swap children if necessary Home work: p.181 5.16 Merge two given leftist heaps p.183 5.22 BuildHeap in O(N) Step 1:Sort the right paths without changing their left children DeleteMin: Step 1:Delete the root Step 2:Merge the two subtrees Tp = O(log N) 6/10

7. Target : Any M consecutive operations take at most O(M log N) time. 3 6 10 3 6 12 21 14 7 10 8 12 7 8 18 24 23 37 21 14 17 18 24 37 18 17 33 23 26 33 26 H1 H2 §7 Skew Heaps -- a simple version of the leftist heaps Merge: Always swap the left and right children except that the largest of all the nodes on the right paths does not have its children swapped. No Npl. Not really a special case, but a natural stop in the recursions. 18 This is NOT always the case. 7/10

8. §7 Skew Heaps 3 3 3 6 6 6 10 10 3 6 14 12 12 12 21 21 14 14 7 7 7 10 10 8 12 7 8 8 8 23 18 18 18 24 24 24 23 23 37 37 37 21 21 14 17 18 24 37 18 18 18 17 17 17 33 33 33 23 26 33 26 26 26 H1 H2 【Example】Insert 15 15 15 Merge (iterative version): 18 8/10

9. §7 Skew Heaps Note:  Skew heaps have the advantage that no extra space is required to maintain path lengths and no tests are required to determine when to swap children.  It is an open problem to determine precisely the expected right path length of both leftist and skew heaps. Home work: p.183 5.24 Insertions 9/10

10. Research Project 3 Lazy Strategy for Leftist Heaps (30) Lazy strategy is another way to delete a node from known position of leftist heaps. Instead of removing the node, we just mark the node deleted until we execute a FindMin or DeleteMin operation. If the root node is marked deleted, FindMin or DeleteMin operation will keep removing the root until the true minimum node is found or removed. You are to analyze the complexities of the above functions, compare with the general strategy and discuss the pros and cons. Detailed requirements can be downloaded from http://www.cs.zju.edu.cn/ds/ 10/10