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 { StdElementelt; 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 2030 40502555 5242 [1]10 [2]203040 [3]2520 [4]304050 [5]405042 [6]422530 [7]505525 [8]52 [9]554255 For the heap shown All the three arrangements satisfy min heap conditions

12. 12 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.

13. 13 ADT Heap Elements: The elements are called HeapElements. public class HeapElement { T data; Priority p; public HeapElement(T e, Priority pty) { data = e; p = pty; Other methods in Java code } Structure: The elements of the heap satisfy the heap conditions. Domain: Bounded. Type name: Heap.

14. 14 ADT Heap Operations: 1.Method SiftUp (int n) requires: Elements H[1],H[2],…,H[n-1] satisfy heap conditions. results: Elements H[1],H[2],…,H[n] satisfy heap conditions. 2.Method SiftDown (int m,n) requires: Elements H[m+1],H[m+2],…,H[n] satisfy the heap conditions. results: Elements H[m],H[m+1],…,H[n] satisfy the heap conditions. 3.Method Heap (int n) // Constructor results: Elements H[1],H[2],….H[n] satisfy the heap conditions.

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) 2 65 79 insertion node 2 65 79 1 z z © 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 2 1 5 79 6 z 1 2 5 79 6 z © 2010 Goodrich, Tamassia

17. Heaps17 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

18. Heaps18 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 7 65 9 w 5 6 7 9 w © 2010 Goodrich, Tamassia

19. Heaps19 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

20. Heaps20 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

21. Heaps21 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

22. Heaps22 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

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

24. Heaps24 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

25. Heaps25 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

26. Heaps26 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

27. Heaps27 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 3 58 2 64 2 3 58 4 6 7 © 2010 Goodrich, Tamassia

28. 28 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.

29. Heaps29 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

30. 30 ADT Heap: Implementation //This method extracts elements in sorted order from the heap. Heap size becomes 0. public void HeapSort(){ while (size>1){ swap(heap, 1, size); size--; SiftDown(1); } //Display the sorted elements. for(int i = 1; i<=maxsize; i++){ System.out.println(heap[i].get_priority().get_value()); }

31. 31 Priority Queue as Heap Representation as a Heap public class HeapPQ { Heap pq; /** Creates a new instance of HeapPQ */ public HeapPQ() { pq = new Heap(10); }

32. 32 Priority Queue as Heap public void enqueue(T e, Priority pty){ HeapElement x = new HeapElement (e, pty); pq.SiftUp(x); }

33. 33 Priority Queue as Heap public T serve(Priority pty){ T e; Priority p; e = pq.heap[1].get_data(); p = pq.heap[1].get_priority(); pty.set_value(p.get_value()); pq.heap[1] = pq.heap[pq.size]; pq.size--; pq.SiftDown(1); return(e); }

34. 34 Priority Queue as Heap public int length(){ return pq.size; } public boolean full(){ return false; }