Introduction to Computing II Lecture 10: Heaps Fall Session 2000

1. 308-203AIntroduction to Computing IILecture 10: Heaps Fall Session 2000

2. Motivation • Data structures supporting extraction of max element • are quite useful, for example: • Priority queues - list of tasks to perform with priority • (always take highest priority task) • Event simulators, e.g. video games • (always simulate the nearest event in the future)

3. Heap Extract-Max() Heap Insert(object, key)

4. How could we do this? • Sorted list: but recall that Insertion-Sort • was suboptimal • Binary tree: but binary trees can become • unbalanced and costly • A more clever way: a special case of binary trees…

5. Arrays as Binary Trees Take an array of n elements: A[1..n] For an index ie[1 .. n] define: Parent(i) = i/2 Left-child(i) = 2i Right-child(i) = 2i + 1

6. Example (as array) 1 2 3 4 5 6 7 8 9 10 11 12 13 14

7. Example (as tree) 1 2 3 4 5 6 7 8 9 10 11 12 13 14

8. Facts • These trees are always balanced • Easy to find next leaf to add • (element n+1 in the array) • Not as flexible as trees built with pointers

9. The Heap Property For any node X with parent PARENT(X): PARENT(X).key > X.key Compare to the Binary Search Tree Property from last lecture: this is a much weaker condition

10. Example 16 14 10 8 7 9 3 2 4 1

11. Heap-Insert Heap-Insert(A[1..n], k) { A.length ++; A[n+1] = k; j = n+1; while (j  1 and A[j] > A[PARENT(j)] { swap(A, j, PARENT(j)); j = PARENT(j); } }

12. Heap-Insert: Example 16 14 10 8 7 9 3 swap 2 4 1 15

13. Heap-Insert: Example 16 14 10 swap 15 8 9 3 2 4 1 7

14. Heap-Insert: Example 16 Done (15 < 16) 10 15 14 8 9 3 2 4 1 7

15. Helper routine: Heapify Given a node X, where X’s children are heaps, guarantee the heap property for the ensemble of X andit’s children X Left heap Right heap

16. Heapify Heapify(A[1..n], i) { l := Left(i); r := Right(i); if (A[i] > A[l] and A[i] > A[r] ) return; if (A[l] > A[r]) swap(A[i], A[l]); Heapify(A, l); else swap(A[i], A[l]); Heapify(A, l); }

17. Heapify: example HEAP PROPERTY VIOLATED 6 14 10 8 7 9 3 2 4 1

18. Heapify: example Swap with max(14, 6, 10) 14 6 10 8 7 9 3 2 4 1

19. Heapify: example Swap with max(8, 6, 7) 14 8 10 6 7 9 3 2 4 1

20. Heapify: example Done: 6 = max(2, 6, 4) 14 8 10 6 7 9 3 2 4 1

21. Heap-Extract-Max Heap-Extract-Max(A[1..n]) { returnValue = A[1]; A[1] = A[n]; heap.length --; Heapify(A[1..(n-1)], 1); return returnValue; }

22. Heap-Extract-Max: example returnValue = 16 16 14 10 8 7 9 3 2 4 1

23. Heap-Extract-Max: example Replace with A[n] 1 14 10 8 7 9 3 2 4

24. Heap-Extract-Max: example Heapify from top 14 8 10 4 7 9 3 2 1

25. Order of Growth All three, proportional to height of tree: O( log n ) O( log n ) O( log n ) Heap-insert Heapify Heap-Extract-Max

26. Other useful operations • Build-Heap: convert an unordered array into a heap • O( n ) • Heap-Sort: sort by removing elements from the heap • until it is empty • O( n log n )

27. Build-Heap Build-Heap(A[1..n]) { for i := n/2 downto 1 Heapify(A, i); }

28. Heap-Sort Heap-Sort(A[1..n]) { result = new array[1..n]; for i := n downto 1 result[i] = Heap-Extract-Max (A[1..i]); return result; }

29. Any questions?