Leftist Heaps. Examples of Leftist Heaps. Leftist Heaps. Class #28: Leftist Heaps & Binomial Queues 18" 9" 18" 9" 18" 9" 11" 28" 19" 11" 19" 28" 30"

Transcription

1 Leftist Heaps Class #28: Leftist Heaps & Binomial Queues Software Design III (CS 340): M. Allen, 04 April 16! An array-based heap efficiently supports operations to insert and find/delete the highest-priority (minimum) item! What about combining two heaps H1 and H2 so that H1 contains all the elements? 1. For each object in H2, we must add() it to H1 2. Worst case for each such add() takes log-time relative to the combined size of the two heaps: Size(H2) * log(size(h2) + Size(H1)) = O(N log N)!! Can be quite bad for large data, so we look at another structure! A leftist heap is a priority queue that more efficiently supports merging, as well as having the usual operations Monday, 4 Apr. 20 Software Design III (CS 340)" 2" Leftist Heaps! A leftist heap is a heap-ordered binary tree that maintains the unbalanced leftist property, defined as follows:! Null Path Length of node N: the length to the first null point (where no more data exists): 1. npl(n) = 0, if N has a null child min(npl(n.left), npl(n.right)), else.! Leftism: For every node N, npl(n.left) npl(n.right)!! This forces tree to be unbalanced (deeper on the left), so the tree is no longer complete, it just respects heap order Examples of Leftist Heaps 9" 28" 19" satisfied 30" 28" 9" satisfied 9" 28" 19" 19" 22" NOT satisfied Monday, 4 Apr. 20 Software Design III (CS 340)" 3" Monday, 4 Apr. 20 Software Design III (CS 340)" 1

2 Leftist Heap Property! Theorem: If the right-most path of a leftist heap has M r nodes, then the whole tree has N 2 r 1 nodes! Proof by induction on the value, r 1. Base Case: r = 1! When r = 1, then at least one node exists, so the overall size of the tree is N 1 (i.e ) nodes 2. Inductive Step: assume the theorem holds for all values up to (r 1), and show that it holds for r itself! We know that both the left and right subtrees of the root have to have right-most paths of length at least (r 1) (WHY?)! Thus, by the inductive assumption, the left and and right subtrees each have at least 2 (r-1) 1 nodes! Entire tree then has N 2 (2 (r 1) 1) + 1 = 2 r 1 nodes Monday, 4 Apr. 20 Software Design III (CS 340)" 5" Merging Leftist Heaps! Leftist property thus means that path length along shorter right-hand path is O(log N) for N total nodes, so we do all our work on that branch merge( H1, H2 )! input: Heaps H1 and H2! output: A heap containing all of H1 and H2! if H1 is empty return H2! if H2 is empty return H1! if H1.root < H2.root:! Least = H1, Most = H2! else! Least = H2, Most = H1! Least.right = merge( Least.right, Most )! Root will be minimum of the two heap roots Merge recursively, always on the right-hand side if Least.left == null OR npl(least.left) < npl(least.right):! swap left and right children of Least heap! Swap children at the end return Least! (if needed) to preserve leftist property Monday, 4 Apr. 20 Software Design III (CS 340)" 6" An Example of Merging Leftist Heaps Least! 8" 28" 19" Most! 17" 30" 7" 17" 9" 17" 30" Monday, 4 Apr. 20 Software Design III (CS 340)" 7" 7" 17" 8" 9" 28" 19" Left-hand side of Least heap.! Never touched (swapped to right at the end).! Leftist Heap Operations! Each recursive call has at most a comparison, a link, and a swap! Total time to merge two leftist heaps with N total elements is now O(log N), considerably better than O(N log N)! We implement all the usual heap operations using the basic merge() operation: 1. insert( x ): make a new heap with the single element x in it, and merge() into existing heap. 2. deletemin(): remove and return root node, after calling merge() on the remaining two subtrees.! All of these can now be done in time O(log N) Monday, 4 Apr. 20 Software Design III (CS 340)" 8" 2

3 A Further Improvement! In a leftist heap, like a regular heap, the worst-case time for inserting and deleting is O(log N)! However, more sophisticated analysis can show that in a regular binary heap, the average time for a series of random insertions will actually be O(1)! This is due to two facts: 1. About half the objects in complete binary tree are leaves 2. About half the time we simply insert an object at a leaf node, and don t bubble up, so no further work is required! For a leftist heap, this is not true: average is also O(log N)! This means that we can build a regular heap of N items in total time O(N), whereas a leftist heap takes O(N log N) Monday, 4 Apr. 20 Software Design III (CS 340)" 9" Binomial Trees! A binomial tree is defined recursively: 1. Binomial tree B 0 with height 0 is a single node. 2. Binomial tree B k with height k is formed by attaching one with height (k 1) to the root of another one with height (k 1) B 0 B 1 B 2 B 3 Note: the root-node of any binomial tree B k has k children Monday, 4 Apr. 20 Software Design III (CS 340)" 10" Binomial Queues! We can now represent a priority queue as a collection of binomial trees with the following overall properties: 1. Every tree in the collection uses the heap ordering. 2. Only one tree of any height k occurs.! E.g.,here are two queues, one with 6 total elements, and one with 7: Q 1 Q 2 13" 1 12" Monday, 4 Apr. 20 Software Design III (CS 340)" Properties of Binomial Queues! Any binomial tree of height k has exactly 2 k nodes (since it is formed recursively by combining pairs of trees)! Thus, since we have at most one tree of any height, the number of trees needed for N objects is at most log N! This follows by simple binary arithmetic! In fact, we can use the binary representation of a number to tell us what trees we need!! Thus, to find/delete the highest priority (least) element of a binomial queue, we simply look at the roots of all the heap-trees, and return the least one, for O(log n) work Monday, 4 Apr. 20 Software Design III (CS 340)" 12" 3

4 Merging Binomial Queues! For two queues, we can create a new collection that contains everything from both by repeatedly merging: 1. Merge any 2 trees of height 0 to create a tree of height Merge any 2 trees of height 1 to create a tree of height Merge any 2 trees of height 2 to create a tree of height Etc.! In each case, we merge by making largest root of the two trees into a child of the other root, which preserves the heap ordering! Repeating for larger and larger trees guarantees uniqueness of each height needed to make the end-result a binomial queue! Again, since there are log N trees in total, where N is the size of the two queues combined, and each step is just a comparison and link (constant-time O(1) operations), we get total time O(log N) Monday, 4 Apr. 20 Software Design III (CS 340)" 13" Merging Binomial Queues! We merge the size-6 and size-7 queues to get one of size 13 (this is one possible result, another equivalent collection could be built): 6 = 110! 7 = 111! 13 = 1101! 13" 1 12" Monday, 4 Apr. 20 Software Design III (CS 340)" 1 13" 12" 1 Inserting into Binomial Queues! Like leftist heap, binomial queue insert() uses merge(): create a new node (height 0 tree), merge into existing queue! Worst-case time O(log N), but: merging can stop as soon as it makes first tree of size k not used to make the original queue! E.g., if queue starts with 13 elements (1101), insert() will merge new node with existing height-0 node, creating a new height-1 node, and then we can stop with new size 14 (1110)! This guarantees what we wanted: average cost of insert() in building binomial queue is constant O(1), and building process takes O(N) time for N objects total Monday, 4 Apr. 20 Software Design III (CS 340)" 15" Efficiency of Operations! Binomial queues thus have the best of both worlds, achieving best-case time for all operations (in blue): Method! insert()! (worst case)! insert()! (average case)! Heap! Leftist Heap! Binomial Queue! O(log N)! O(log N)! O(log n)! O(1)! O(log N)! O(1)! deletemin()! O(log N)! O(log N)! O(log n)! merge()! O(N log N)! O(log N)! O(log n)! build()! (N items total)! O(N)! O(N log N)! O(N)! Monday, 4 Apr. 20 Software Design III (CS 340)" 4

5 This Week! Reading: Leftist Heaps & Binomial Queues (Chapter 6)! Meet: no lab this week! Monday/Wednesday/Friday: regular classroom! Midterm 02: Wednesday, 06 April, in class! Office Hours: Wing 210! Tuesday & Thursday: 10:00 11:30 AM! Tuesday & Thursday: 4:00 5:30 PM Monday, 4 Apr. 20 Software Design III (CS 340)" 17" 5