1. David Luebke 1 12/23/2015 Heaps & Priority Queues

2. David Luebke 2 12/23/2015 l A heap can be seen as a complete binary tree: n What makes a binary tree complete? n Is the example above complete? Heaps 16 1410 8793 241

3. David Luebke 3 12/23/2015 l A heap can be seen as a complete binary tree: n The book calls them “nearly complete” binary trees; can think of unfilled slots as null pointers Heaps 16 1410 8793 241 1 1 1 11

4. David Luebke 4 12/23/2015 Heaps l In practice, heaps are usually implemented as arrays: 16 1410 8793 241 1614108793241 A ==

5. David Luebke 5 12/23/2015 Heaps l To represent a complete binary tree as an array: n The root node is A[0] n Node i is A[i] n The parent of node i is A[(i-1)/2] (note: integer divide) n The left child of node i is A[2i+1] n The right child of node i is A[2i+2] 16 1410 8793 241 1614108793241 A ==

6. David Luebke 6 12/23/2015 Referencing Heap Elements l So… Parent(i) { return  (i-1)/2  ; } Left(i) { return 2*i + 1; } right(i) { return 2*i + 2; } l An aside: Multiplying and Dividing by 2 in code is super efficient. Do you know why?

7. David Luebke 7 12/23/2015 The Heap Property l Heaps also satisfy the heap property: A[Parent(i)]  A[i]for all nodes i > 1 n In other words, the value of a node is at most the value of its parent n Where is the largest element in a heap stored?

8. David Luebke 8 12/23/2015 Heap Height l Definitions: n The height of a node in the tree = the number of edges on the longest downward path to a leaf n The height of a tree = the height of its root l What is the height of an n-element heap? Why? l This is nice: basic heap operations take at most time proportional to the height of the heap

9. David Luebke 9 12/23/2015 Heap Operations: Heapify() Heapify() : maintain the heap property n Given: a node i in the heap with children l and r n Given: two subtrees rooted at l and r, assumed to be heaps n Problem: The subtree rooted at i may violate the heap property (How?) n Action: let the value of the parent node “float down” so subtree at i satisfies the heap property u What do you suppose will be the basic operation between i, l, and r?

10. David Luebke 10 12/23/2015 Heap Operations: Heapify() Heapify(A, i) { l = Left(i); r = Right(i); if (l A[i]) largest = l; else largest = i; if (r A[largest]) largest = r; if (largest != i) Swap(A, i, largest); Heapify(A, largest); }

11. David Luebke 11 12/23/2015 Heapify() Example 16 410 14793 281 1641014793281 A =

12. David Luebke 12 12/23/2015 Heapify() Example 16 410 14793 281 161014793281 A = 4

13. David Luebke 13 12/23/2015 Heapify() Example 16 410 14793 281 1610793281 A = 414

14. David Luebke 14 12/23/2015 Heapify() Example 16 1410 4793 281 1614104793281 A =

15. David Luebke 15 12/23/2015 Heapify() Example 16 1410 4793 281 161410793281 A = 4

16. David Luebke 16 12/23/2015 Heapify() Example 16 1410 4793 281 16141079321 A = 48

17. David Luebke 17 12/23/2015 Heapify() Example 16 1410 8793 241 1614108793241 A =

18. David Luebke 18 12/23/2015 Heapify() Example 16 1410 8793 241 161410879321 A = 4

19. David Luebke 19 12/23/2015 Heapify() Example 16 1410 8793 241 1614108793241 A =

20. David Luebke 20 12/23/2015 Analyzing Heapify(): Informal Aside from the recursive call, what is the running time of Heapify() ? How many times can Heapify() recursively call itself? What is the worst-case running time of Heapify() on a heap of size n?

21. David Luebke 21 12/23/2015 Analyzing Heapify(): Formal l Fixing up relationships between i, l, and r takes  (1) time l If the heap at i has n elements, how many elements can the subtrees at l or r have? n Draw it l Answer: 2n/3 (worst case: bottom row 1/2 full) So time taken by Heapify() is given by T(n)  T(2n/3) +  (1)

22. David Luebke 22 12/23/2015 Analyzing Heapify(): Formal l So we have T(n)  T(2n/3) +  (1) l By case 2 of the Master Theorem, T(n) = O(lg n) Thus, Heapify() takes logarithmic time

23. David Luebke 23 12/23/2015 Heap Operations: BuildHeap() We can build a heap in a bottom-up manner by running Heapify() on successive subarrays n Fact: for array of length n, all elements in range A[  n/2 .. n-1] are heaps (Why?) n So:  Walk backwards through the array from n/2-1 to 0, calling Heapify() on each node. u Order of processing guarantees that the children of node i are heaps when i is processed

24. David Luebke 24 12/23/2015 BuildHeap() // given an unsorted array A, make A a heap BuildHeap(A) { heap_size(A) = length(A); for (i =  length[A]/2  -1 downto 0) Heapify(A, i); }

25. David Luebke 25 12/23/2015 BuildHeap() Example l Work through example A = {4, 1, 3, 2, 16, 9, 10, 14, 8, 7} 4 13 216910 1487

26. David Luebke 26 12/23/2015 Heapsort Given BuildHeap(), an in-place sorting algorithm is easily constructed: n Maximum element is at A[0] n Discard by swapping with element at A[n-1] u Decrement heap_size[A] u A[n-1] now contains correct value Restore heap property at A[0] by calling Heapify() n Repeat, always swapping A[0] for A[heap_size(A- 1)]

27. David Luebke 27 12/23/2015 Heapsort Heapsort(A) { BuildHeap(A); for (i = length(A)-1 downto 1) { Swap(A[0], A[i]); heap_size(A) -= 1; Heapify(A, 0); }

28. Inserting into a Heap l Unlike in BuildHeap, we already have a heap, want a new element in it. l Idea – put it at the end of the heap and let it “bubble” up the heap until it’s in the right spot. David Luebke 28 12/23/2015

29. Insert David Luebke 29 12/23/2015 16 1410 8793 2 Add element: 15

30. Insert David Luebke 30 12/23/2015 16 1410 8793 215

31. Insert David Luebke 31 12/23/2015 16 1410 15793 28

32. Insert David Luebke 32 12/23/2015 16 1510 14793 28

33. Insert Insert key into heap A Insert-key(A, key): size <- size + 1 A[size-1] <- key i <- size-1 while i > 0 and A[Parent(i)] < A[i] swap(A[i], A[Parent(i)] i<- Parent(i) David Luebke 33 12/23/2015

34. Analyze the running time Insert key into heap A Insert-key(A, key): size <- size + 1 A[size-1] <- key i <- size-1 while i > 0 and A[Parent(i)] < A[i] swap(A[i], A[Parent(i)] i<- Parent(i) David Luebke 34 12/23/2015

35. David Luebke 35 12/23/2015 Priority Queues l Heapsort is a nice algorithm, but in practice Quicksort (coming up) usually wins l But the heap data structure is incredibly useful for implementing priority queues n A data structure for maintaining a set S of elements, each with an associated value or key Supports the operations Insert(), Maximum(), and ExtractMax() n What might a priority queue be useful for?

36. David Luebke 36 12/23/2015 Priority Queue Operations l Insert(S, x) inserts the element x into set S l Maximum(S) returns the element of S with the maximum key l ExtractMax(S) removes and returns the element of S with the maximum key l How could we implement these operations using a heap?