Heaps Outline and Required Reading: Heaps ( 7.3) COSC 2011, Fall 2003, Section A Instructor: N. Vlajic

Transcription

1 1 Heaps Outline and Required Reading: Heaps (.3) COSC 2011, Fall 2003, Section A Instructor: N. Vlajic

2 Heap ADT 2 Heap binary tree (T) that stores a collection of keys at its internal nodes and satisfies two additional properties: (1) Relational Min Heap-Order Property The key stored in each node (v) is greater than or equal to the key stored at that node s parent. key(v) key(v.parent()) The consequences of property (1) are: The keys encountered on a path from the root to an external node of T are in non-decreasing order. The minimum key is always stored at the root of T!!! What is the complexity of removing the minimum key form a Heap?!

3 Heap ADT (cont.) 3 (2) Structural Complete Binary Tree Property The heap tree (T) must be complete binary tree. Complete binary tree with height h: the levels 0, 1, 2,.., h-2 have the max number of nodes possible (2 i ), and in level (h-1) all the internal nodes are to the left of the external nodes. Complete binary trees are balanced by definition! In in-order traversal of T, all internal nodes of level (h-1) will be visited before any external nodes of that level last node right-most deepest internal node in a heap

4 Heap ADT (cont.) 4 Theorem: A heap T storing n keys has height. h = log(n + 1) Proof Let us assume that T s height (h) is known. The number of internal nodes (n) in T is at least: h = 2 h The number of internal nodes (n) in T is at most: h-1 = 2 h -1 h-2 h-1 h h-1 n 2 h 1 log(n+1) h log(n) + 1 log(n+1) h < log(n+1) +1 If we can perform update operations on a heap in time proportional to h, then those operations will run in logarithmic time, with respect to n!!!

5 Insertion into Heap Implementation of insertitem(k,e) in Heaps STEP 1 Find the correct insertion node (z). insertion must preserve complete binary tree property if the last node (w) is the right-most node on its level, z is the leftmost node on the bottom level; otherwise, z is immediately to the right of w STEP 2 Expand z into an internal node, and store (k,e) in z. STEP 3 Restore the heap-order property with up-heap algorithm w 29 z 29 k 29 k

6 Insertion into Heap (cont.) 6 Up-Heap Bubbling Algorithm algorithm for restoring heap-order property upon insertion of a new node compare key(z) with key(z.parent()) if key(z) < key(z.parent()) swap z with its parent if heap-order property is still not restored, keep swapping z with its ancestor(s) until no violation of heap-order property occurs or the root has been reached Since heap s height = O(log(n)), up-heap procedure runs in O(log(n)) time!!!

7 Insertion into Heap (cont.) Up-heap procedure restores heap-order property along one branch of T. What happens with other branches? A B 10 C 29 B C A Before swap(a,b): C>A and B<A ok still ok! After swap(a,b): C(>A)>B and A>B

8 Removal from Heap 8 Implementation of removemin() in Heaps (Item with smallest key is at the root however, the root cannot be deleted!) STEP 1 Access the last node (w) and copy its (k,e) pair to the root. STEP 2 Compress the last node and its children into a leaf by performing removeaboveexternal(t.rightchild(w)). STEP 3 Restore the heap-order property with down-heap algorithm w 29 w 29

9 Removal from Heap (cont.) 9 Down-Heap Bubbling Algorithm algorithm for restoring heap-order property upon removal of the min-key item let s be the child of root (r) with smaller key (if r has only one child, s becomes that child) if key(r) > key(s) swap r and s if heap-order property is still not restored, keep swapping r with its children until no violation of heap-order property occurs or a leaf node has been reached Why?! Since a heap has height O(log(n)), down-heap procedure runs in O(log(n)) time!!!

10 Heap and Priority Queues 10 Implementing PQs with Heaps store a (key,element) item at each internal node keep track of the positions (references) to the root and last node (Why?!) minelement() and minkey() take O(1) time expandexternal and removeaboveexternal both run in O(1); up and down heap bubbling run in O(log(n)) insertitem and removemin take O(log(n))! in vector implementation, this assumes that no vector expansion is necessary

11 Heap and Priority Queues (cont.) 11 Vector Based Heap-PQ Implementation the index of last node is always equal to n the 1 st empty external node has index (n+1)! last, i.e. insert, node location are found in O(1) time all external nodes have indices higher than any internal node, so external nodes do not have to be explicitly stored No element at rank 0!

12 Heap and Priority Queues (cont.) 12 Linked-Structure Based Heap-PQ Implementation the reference to the last node is known still, it takes O(log(n)) time to find the 1 st empty external node Find Insertion Node algorithm:! go up until a left child or the root is reached; if a left child is reached, go the the right child! go down left until a leaf is reached Example (a) Example (b)

13 Heap and Priority Queues (cont.) 13 Running Times PQ realized by means of array-based heap provides slightly faster insertitem method! new insert location is directly accessible Method size, isempty minelement, minkey insertitem removemin RT O(1) O(1) O(log(n)) O(log(n)) Max-Heap Property General Heap Property Each node has a key which is less than or equal to the key of its parent. Each node has a key which is more extreme ( or ) than the key of its parent.

14 Max-Heap 14 Example 1 [ merging two heaps in log time ] Describe an algorithm which, given a pointer to the root of a max-heap and a number t, prints all the keys in the heap that are larger than t. The algorithm complexity should be θ(k), where k denotes the actual number of keys in the heap greater than t Start from the root. If the key of the current node is smaller than t (i.e. k t) return. Otherwise, print the key value and continue recursively with the node s children.

15 Merging Two Heaps 1 Example 2 [ merging two heaps in log time ] Give an algorithm to merge two heaps of size m and n (assume n m), but the same height, into a single heap of size (m+n) in time O(log(n)) = O(log(max(n,m)). H 1 size: m H 2 size: n Compare the min elements from H 1 and H 2 ; denote the smaller as x and the greater as y. Remove x from the corresponding heap (H x ) using removemin(), and store it in a separate node; running time: O(height(H x )) O(log(n)). Both, the new root of re-heapified H x and y are smaller than x new binary tree created by making the two heaps children of x is also a heap.

16 Merging Two Heaps (cont.) H 1 after removemin and down-heap bubbling H H 1 and H 2 merged We cannot stop here. What else should be done?

17 Heap-Sort 1 PriorityQueueSort scheme for sorting a sequence of elements using an auxiliary heap-based PQ Phase (1) Put the items of S into an initially empty PQ by means of n insertitem() operations cost: O(nlog(n)) Phase (2) Extract the items from PQ by means of n removemin() operations, and put them back in S cost: O(nlog(n)) Overall complexity of Heap-Sort: O(nlog(n)) S S Q

18 Heap Construction 18 Top-Down Construction heap of size n can be constructed by means of n successive insertitem operations on-line approach keys are added to the heap as they become available first item gets placed at the top level; subsequently added items get placed at lower levels overall complexity: O(nlog(n)) heap after 1 st insertitem operation heap after 2 nd insertitem operation 8 heap after 4 th insertitem operation

19 Heap Construction (cont.) 19 Bottom-Up Construction recursive procedure based on the concept of heap merging off-line approach all keys must be known in advance overall complexity: O(n)!!! Assume the number of keys n = 2 h 1. Step 1: store (n+1)/2 keys in elementary one-node heaps Step 2: form (n+1)/4 heaps, each by joining pairs of elementary heaps and adding a new key perform down-heap bubbling where needed Step i: form (n+1)/2 i heaps, each by joining pairs of heaps constructed in the previous step and adding a new key perform down-heap bubbling where needed

20 Heap Construction (cont.) 20 Keys: 14,, 21, 3, 10, 9, Step 1 Step 2.a) Step 2.b) Step 3.a) Step 3.b)

21 Heap Construction (cont.) 21 Bottom-Up Construction Complexity Assume the number of keys n = 2 h 1. Step 1: (n+1)/2 Step 2: O [ (n+1)/4 + (n+1)/4 ] merging bubbling Step i: O [ (n+1)/2 i + ((n+1)/2 i )*(i-1) ] Step h: O [ (n+1)/2 h + ((n+1)/2 h )*(h-1) ] = O [ (n+1)/2 h + ((n+1)/2 h )*log(n) ] RT(n) h h (n + 1) i = i = (n + 1) i= 1 2 i= 1 2 h + 2 = (n + 1) 2 h 2 2 (n + i i arithmetic power series 1) RT(n) = O(n)

22 Heaps: Questions 22 Q.1 The most appropriate way to implement a heap is with an array rather than a linked structure. Why?! Q.2 Start with an empty heap; enter 10 elements with priorities 1 through 10. Draw the resulting heap. Remove three elements from the heap you created in the previous exercise. Draw the resulting heap.