1. 1 Heaps A heap is a binary tree. A heap is best implemented in sequential representation (using an array). Two important uses of heaps are: –(i) efficient implementation of priority queues –(ii) sorting -- Heapsort.

2. 2 A Heap 10 2030 40502555 5242 Any node’s key value is less than its children’s.

3. 3 Sequential Representation of Trees There are three methods of representing a binary tree using array representation. 1. Using index values to represent edges: class Node { Dataelt; intleft; intright; } Node; Node[] BinaryTree[TreeSize];

4. 4 Method 1: Example A D BC E G I IndexElementLeftRight 1A23 2B46 3C00 4D00 5I00 6E70 7G50

5. 5 Method 2 2. Store the nodes in one of the natural traversals: class Node { Dataelt; booleanleft; booleanright; }; Node[] BinaryTree[TreeSize];

6. 6 Method 2: Example A D BC E G I IndexElementLeftRight 1ATT 2BTT 3DFF 4ETF 5GTF 6IFF 7CFF Elements stored in Pre-Order traversal

7. 7 Method 3 3. Store the nodes in fixed positions: (i) root goes into first index, (ii) in general left child of tree[i] is stored in tree[2i] and right child in tree[2i+1].

8. 8 Method 3: Example A D BC E G ABCDE----G- 123456789101112

9. 9 Heaps Heaps are represented sequentially using the third method. Heap is a complete binary tree: shortest-path length tree with nodes on the lowest level in their leftmost positions. Complete Binary Tree: let h be the height of the heap –for i = 0, …, h - 1, there are 2 i nodes of depth i –at depth h - 1, the internal nodes are to the left of the external nodes

10. Heaps (Cont.) Max-Heap has max element as root. Min- Heap has min element as root. The elements in a heap satisfy heap conditions: for Min-Heap: key[parent] < key[left-child] or key[right-child]. The last node of a heap is the rightmost node of maximum depth 10 2 65 79 last node

11. 11 Heap: An example 10 2520 30404250 5255 [1]10 [2]203040 [3]2520 [4]304050 [5]405042 [6]422530 [7]505525 [8]52 [9]554255 All the three arrangements satisfy min heap conditions

12. 12 Heap: An example 10 2030 40502555 5242 [1]10 [2]203040 [3]2520 [4]304050 [5]405042 [6]422530 [7]505525 [8]52 [9]554255 All the three arrangements satisfy min heap conditions

13. 13 Heap: An example 10 2040 50423025 5255 [1]10 [2]203040 [3]2520 [4]304050 [5]405042 [6]422530 [7]505525 [8]52 [9]554255 All the three arrangements satisfy min heap conditions

14. 14 Constructing Heaps There are two methods of constructing heaps: –Using SiftDown operation. –Using SiftUp operation. SiftDown operation inserts a new element into the Heap from the top. SiftUp operation inserts a new element into the Heap from the bottom.

15. Heaps15 Insertion into a Heap Method insertItem of the priority queue ADT corresponds to the insertion of a key k to the heap The insertion algorithm consists of three steps –Find the insertion node z (the new last node) –Store k at z –Restore the heap-order property (discussed next) © 2010 Goodrich, Tamassia

16. Heaps16 Upheap After the insertion of a new key k, the heap-order property may be violated Algorithm upheap restores the heap-order property by swapping k along an upward path from the insertion node Upheap terminates when the key k reaches the root or a node whose parent has a key smaller than or equal to k Since a heap has height O(log n), upheap runs in O(log n) time © 2010 Goodrich, Tamassia 2 65 79 insertion node z

17. Heaps17 Upheap After the insertion of a new key k, the heap-order property may be violated Algorithm upheap restores the heap-order property by swapping k along an upward path from the insertion node Upheap terminates when the key k reaches the root or a node whose parent has a key smaller than or equal to k Since a heap has height O(log n), upheap runs in O(log n) time © 2010 Goodrich, Tamassia 2 65 79 1

18. Heaps18 Upheap After the insertion of a new key k, the heap-order property may be violated Algorithm upheap restores the heap-order property by swapping k along an upward path from the insertion node Upheap terminates when the key k reaches the root or a node whose parent has a key smaller than or equal to k Since a heap has height O(log n), upheap runs in O(log n) time © 2010 Goodrich, Tamassia 2 15 79 6

19. Heaps19 Upheap After the insertion of a new key k, the heap-order property may be violated Algorithm upheap restores the heap-order property by swapping k along an upward path from the insertion node Upheap terminates when the key k reaches the root or a node whose parent has a key smaller than or equal to k Since a heap has height O(log n), upheap runs in O(log n) time © 2010 Goodrich, Tamassia 1 25 79 6

20. Heaps20 Upheap After the insertion of a new key k, the heap-order property may be violated Algorithm upheap restores the heap-order property by swapping k along an upward path from the insertion node Upheap terminates when the key k reaches the root or a node whose parent has a key smaller than or equal to k Since a heap has height O(log n), upheap runs in O(log n) time © 2010 Goodrich, Tamassia 1 25 79 6 insertion node z

21. Heaps21 Upheap After the insertion of a new key k, the heap-order property may be violated Algorithm upheap restores the heap-order property by swapping k along an upward path from the insertion node Upheap terminates when the key k reaches the root or a node whose parent has a key smaller than or equal to k Since a heap has height O(log n), upheap runs in O(log n) time © 2010 Goodrich, Tamassia 1 25 79 610

22. Heaps22 Upheap After the insertion of a new key k, the heap-order property may be violated Algorithm upheap restores the heap-order property by swapping k along an upward path from the insertion node Upheap terminates when the key k reaches the root or a node whose parent has a key smaller than or equal to k Since a heap has height O(log n), upheap runs in O(log n) time © 2010 Goodrich, Tamassia 1 25 79 610 insertion node z

23. Heaps23 Upheap After the insertion of a new key k, the heap-order property may be violated Algorithm upheap restores the heap-order property by swapping k along an upward path from the insertion node Upheap terminates when the key k reaches the root or a node whose parent has a key smaller than or equal to k Since a heap has height O(log n), upheap runs in O(log n) time © 2010 Goodrich, Tamassia 1 25 79 610 4

24. Heaps24 Upheap After the insertion of a new key k, the heap-order property may be violated Algorithm upheap restores the heap-order property by swapping k along an upward path from the insertion node Upheap terminates when the key k reaches the root or a node whose parent has a key smaller than or equal to k Since a heap has height O(log n), upheap runs in O(log n) time © 2010 Goodrich, Tamassia 1 25 74 610 9

25. Heaps25 Upheap After the insertion of a new key k, the heap-order property may be violated Algorithm upheap restores the heap-order property by swapping k along an upward path from the insertion node Upheap terminates when the key k reaches the root or a node whose parent has a key smaller than or equal to k Since a heap has height O(log n), upheap runs in O(log n) time © 2010 Goodrich, Tamassia 1 24 75 610 9

26. Heaps26 Removal from a Heap (§ 7.3.3) Method removeMin of the priority queue ADT corresponds to the removal of the root key from the heap The removal algorithm consists of three steps –Replace the root key with the key of the last node w –Remove w –Restore the heap-order property (discussed next) 2 65 79 last node w 7 65 9 w new last node © 2010 Goodrich, Tamassia

27. Heaps27 Downheap After replacing the root key with the key k of the last node, the heap- order property may be violated Algorithm downheap restores the heap-order property by swapping key k along a downward path from the root Upheap terminates when key k reaches a leaf or a node whose children have keys greater than or equal to k Since a heap has height O(log n), downheap runs in O(log n) time © 2010 Goodrich, Tamassia 2 65 79 last node w

28. Heaps28 Downheap After replacing the root key with the key k of the last node, the heap- order property may be violated Algorithm downheap restores the heap-order property by swapping key k along a downward path from the root Upheap terminates when key k reaches a leaf or a node whose children have keys greater than or equal to k Since a heap has height O(log n), downheap runs in O(log n) time © 2010 Goodrich, Tamassia 7 65 79 last node w

29. Heaps29 Downheap After replacing the root key with the key k of the last node, the heap- order property may be violated Algorithm downheap restores the heap-order property by swapping key k along a downward path from the root Upheap terminates when key k reaches a leaf or a node whose children have keys greater than or equal to k Since a heap has height O(log n), downheap runs in O(log n) time © 2010 Goodrich, Tamassia 7 65 9 delete last node w

30. Heaps30 Downheap After replacing the root key with the key k of the last node, the heap- order property may be violated Algorithm downheap restores the heap-order property by swapping key k along a downward path from the root Upheap terminates when key k reaches a leaf or a node whose children have keys greater than or equal to k Since a heap has height O(log n), downheap runs in O(log n) time © 2010 Goodrich, Tamassia 7 65 9 DownHeap/SiftDown

31. Heaps31 Downheap After replacing the root key with the key k of the last node, the heap- order property may be violated Algorithm downheap restores the heap-order property by swapping key k along a downward path from the root Upheap terminates when key k reaches a leaf or a node whose children have keys greater than or equal to k Since a heap has height O(log n), downheap runs in O(log n) time © 2010 Goodrich, Tamassia 5 67 9

32. Heaps32 Downheap After replacing the root key with the key k of the last node, the heap- order property may be violated Algorithm downheap restores the heap-order property by swapping key k along a downward path from the root Upheap terminates when key k reaches a leaf or a node whose children have keys greater than or equal to k Since a heap has height O(log n), downheap runs in O(log n) time © 2010 Goodrich, Tamassia 5 67 9 last node w

33. Heaps33 Downheap After replacing the root key with the key k of the last node, the heap- order property may be violated Algorithm downheap restores the heap-order property by swapping key k along a downward path from the root Upheap terminates when key k reaches a leaf or a node whose children have keys greater than or equal to k Since a heap has height O(log n), downheap runs in O(log n) time © 2010 Goodrich, Tamassia 9 67 9 last node w

34. Heaps34 Downheap After replacing the root key with the key k of the last node, the heap- order property may be violated Algorithm downheap restores the heap-order property by swapping key k along a downward path from the root Upheap terminates when key k reaches a leaf or a node whose children have keys greater than or equal to k Since a heap has height O(log n), downheap runs in O(log n) time © 2010 Goodrich, Tamassia 9 67 delete last node w

35. Heaps35 Downheap After replacing the root key with the key k of the last node, the heap- order property may be violated Algorithm downheap restores the heap-order property by swapping key k along a downward path from the root Upheap terminates when key k reaches a leaf or a node whose children have keys greater than or equal to k Since a heap has height O(log n), downheap runs in O(log n) time © 2010 Goodrich, Tamassia 9 67 DownHeap/SiftDown

36. Heaps36 Downheap After replacing the root key with the key k of the last node, the heap- order property may be violated Algorithm downheap restores the heap-order property by swapping key k along a downward path from the root Upheap terminates when key k reaches a leaf or a node whose children have keys greater than or equal to k Since a heap has height O(log n), downheap runs in O(log n) time © 2010 Goodrich, Tamassia 6 97

37. Heaps37 Downheap After replacing the root key with the key k of the last node, the heap- order property may be violated Algorithm downheap restores the heap-order property by swapping key k along a downward path from the root Upheap terminates when key k reaches a leaf or a node whose children have keys greater than or equal to k Since a heap has height O(log n), downheap runs in O(log n) time © 2010 Goodrich, Tamassia 6 97 last node w

38. Heaps38 Downheap After replacing the root key with the key k of the last node, the heap- order property may be violated Algorithm downheap restores the heap-order property by swapping key k along a downward path from the root Upheap terminates when key k reaches a leaf or a node whose children have keys greater than or equal to k Since a heap has height O(log n), downheap runs in O(log n) time © 2010 Goodrich, Tamassia 9 97 last node w

39. Heaps39 Downheap After replacing the root key with the key k of the last node, the heap- order property may be violated Algorithm downheap restores the heap-order property by swapping key k along a downward path from the root Upheap terminates when key k reaches a leaf or a node whose children have keys greater than or equal to k Since a heap has height O(log n), downheap runs in O(log n) time © 2010 Goodrich, Tamassia 9 7 delete last node w

40. Heaps40 Downheap After replacing the root key with the key k of the last node, the heap- order property may be violated Algorithm downheap restores the heap-order property by swapping key k along a downward path from the root Upheap terminates when key k reaches a leaf or a node whose children have keys greater than or equal to k Since a heap has height O(log n), downheap runs in O(log n) time © 2010 Goodrich, Tamassia 9 7 DownHeap/SiftDown

41. Heaps41 Downheap After replacing the root key with the key k of the last node, the heap- order property may be violated Algorithm downheap restores the heap-order property by swapping key k along a downward path from the root Upheap terminates when key k reaches a leaf or a node whose children have keys greater than or equal to k Since a heap has height O(log n), downheap runs in O(log n) time © 2010 Goodrich, Tamassia 7 9

42. Heaps42 Updating the Last Node The insertion node can be found by traversing a path of O(log n) nodes –Go up until a left child or the root is reached –If a left child is reached, go to the right child –Go down left until a leaf is reached Similar algorithm for updating the last node after a removal © 2010 Goodrich, Tamassia

43. Heaps43 Heap-Sort Consider a priority queue with n items implemented by means of a heap –the space used is O(n) –methods insert and removeMin take O(log n) time –methods size, isEmpty, and min take time O(1) time Using a heap-based priority queue, we can sort a sequence of n elements in O(n log n) time The resulting algorithm is called heap-sort Heap-sort is much faster than quadratic sorting algorithms, such as insertion-sort and selection-sort © 2010 Goodrich, Tamassia

44. Heaps44 Vector-based Heap Implementation We can represent a heap with n keys by means of a vector of length n  1 For the node at rank i –the left child is at rank 2i –the right child is at rank 2i  1 Links between nodes are not explicitly stored The cell of at rank 0 is not used Operation insert corresponds to inserting at rank n  1 Operation removeMin corresponds to removing at rank n Yields in-place heap-sort 2 65 79 25697 123450 © 2010 Goodrich, Tamassia

45. Heaps45 We can construct a heap storing n given keys in using a bottom-up construction with log n phases In phase i, pairs of heaps with 2 i  1 keys are merged into heaps with 2 i  1  1 keys Bottom-up Heap Construction 2 i  1 2i112i11 © 2010 Goodrich, Tamassia

46. Heaps46 Example 1516 12476 2023 25 1516 5 124 11 76 27 2023 © 2010 Goodrich, Tamassia

47. Heaps47 Example (contd.) 25 1516 5 124 11 96 27 2023 15 25 16 4 12 5 6 9 11 23 20 27 © 2010 Goodrich, Tamassia

48. Heaps48 Example (contd.) 7 15 2516 4 125 8 6 911 23 2027 4 15 2516 5 12 7 6 8 911 23 2027 © 2010 Goodrich, Tamassia

49. Heaps49 Example (end) 4 15 2516 5 127 10 6 8 911 23 2027 5 15 2516 7 12 10 4 6 8 911 23 2027 © 2010 Goodrich, Tamassia

50. Heaps50 Merging Two Heaps We are given two two heaps and a key k We create a new heap with the root node storing k and with the two heaps as subtrees We perform downheap to restore the heap-order property © 2010 Goodrich, Tamassia 3 58 2 64

51. Heaps51 Merging Two Heaps We are given two two heaps and a key k We create a new heap with the root node storing k and with the two heaps as subtrees We perform downheap to restore the heap-order property 7 3 58 2 64 © 2010 Goodrich, Tamassia k

52. Heaps52 Merging Two Heaps We are given two two heaps and a key k We create a new heap with the root node storing k and with the two heaps as subtrees We perform downheap to restore the heap-order property 7 3 58 2 64 © 2010 Goodrich, Tamassia k Merge

53. Heaps53 Merging Two Heaps We are given two two heaps and a key k We create a new heap with the root node storing k and with the two heaps as subtrees We perform downheap to restore the heap-order property 7 3 58 2 64 © 2010 Goodrich, Tamassia Downheap/SiftDown

54. Heaps54 Merging Two Heaps We are given two two heaps and a key k We create a new heap with the root node storing k and with the two heaps as subtrees We perform downheap to restore the heap-order property 2 3 58 7 64 © 2010 Goodrich, Tamassia Downheap/SiftDown

55. Heaps55 Merging Two Heaps We are given two two heaps and a key k We create a new heap with the root node storing k and with the two heaps as subtrees We perform downheap to restore the heap-order property 2 3 58 4 67 © 2010 Goodrich, Tamassia Downheap/SiftDown

56. 56 ADT Heap Elements: The elements are called HeapElements. Structure: The elements of the heap satisfy the heap conditions. Domain: Bounded. Type name: Heap.

57. 57 ADT Heap Operations: Method SiftUp () Input: none. requires: Elements H[1],H[2],…,H[n-1] satisfy heap conditions. results: Elements H[1],H[2],…,H[n] satisfy heap conditions. Output: none. Method SiftDown (int i) Input: i. requires: Elements H[i+1],H[i+2],…,H[n] satisfy the heap conditions. results: Elements H[i],H[i+1],…,H[n] satisfy the heap conditions. Output: none. Method Insert(int key, T data) input: key, data. requires: Elements H[1],H[2],…,H[n] satisfy heap conditions. results: The key and data are inserted in H[n+1]. Elements H[1],H[2],….H[n+1] must satisfy the heap conditions. Output: none

58. 58 ADT Heap Operations: Method RemoveRoot(HeapElement result) input: none. requires: Elements H[1],H[2],…,H[n] satisfy heap condition. results: The HeapElement in H[1] is removed, and it is value is assigned to result. Elements H[1],H[2],….H[n-1] must satisfy the heap conditions. output: none. Method Full(boolean result) Method Size(boolean result)

59. ADT Heap: Element public class HeapElem { public int key; public T data; public HeapElem(int _key, T _data){ key= _key; data= _data; } 59

60. Heaps60 Heaps and Priority Queues We can use a heap to implement a priority queue We store a (key, element) item at each internal node We keep track of the position of the last node (2, Sue) (6, Mark)(5, Pat) (9, Jeff)(7, Anna) © 2010 Goodrich, Tamassia

61. 61 Priority Queue as Heap Representation as a Heap public class HeapPQ { private Heap heap; public HeapPQ(int _maxSize){ heap= new Heap (_maxSize); }

62. 62 Priority Queue as Heap public int length(){ return heap.size(); } public boolean full(){ return heap.full(); } public void enqueue(int pr, T val){ heap.insert(pr, val); } public HeapElem serve(){ return heap.removeRoot(); }

63. 63 HeapSort Heap can be used for sorting. Two step process: –Step 1: the data is put in a heap. –Step 2: the data are extracted from the heap in sorted order. HeapSort based on the idea that heap always has the smallest or largest element at the root.

64. 64 ADT Heap: Implementation public void sort(){ int n= size; for(int i= 1; i<=n; i++){ int tmpKey= keys[1]; T tmpData= data[1]; keys[1]= keys[size]; data[1]= data[size]; size--; siftDown(1); keys[size+1]= tmpKey; data[size+1]= tmpData; }