1. Chapter 12 Heaps & HeapSort © John Urrutia 2014, All Rights Reserved1

2. Heaps – Versus – Priority Queues Priority queues implemented as sorted arrays Insertion – O(N) (slow) Deletion – O(1) (fast) Heaps implemented as an array Insertion – O(logN) (faster than PQs) Deletion – O(logN) (slower than PQs) © John Urrutia 2014, All Rights Reserved2

3. Heaps – Versus – Priority Queues Conceptually – Priority Queues are wrappers for Heaps or Arrays The methods are same Both are ADT’s © John Urrutia 2014, All Rights Reserved3

4. Introduction to Heaps A heap is a binary tree with conditions. Completeness All levels are full except the lowest All nodes on the lowest level are filled left to right with no gaps Heap Condition Each node’s key >= the keys of its children Heaps are weakly ordered binary trees Lacks the ability to traverse in order Every path from root to leaf are in descending order Each path is independent of every other. © John Urrutia 2014, All Rights Reserved4

5. Heap Nodes public Node { private int iData; public Node(int key) { iData = key; } public int getKey() { return iData; } public void setKey(int id) { iData = id; } } © John Urrutia 2014, All Rights Reserved5

6. Heap Array class Heap {private Node[] heapArray; private int maxSize = 256; private int currentSize = 0; public Heap(int mx) {maxSize = mx; currentSize = 0; heapArray = new Node[maxSize]; } © John Urrutia 2014, All Rights Reserved6

7. Heap 100 102055 30 45 605070 9080 40450 © John Urrutia 2014, All Rights Reserved7

8. Heap Array Implementation © John Urrutia 2014, All Rights Reserved8

9. Introduction to Heaps Creating the array to hold the heap Given array index for a node X : The parent of X is – ( X -1)/2 The left Child of X is – 2 * X + 1 The right Child of X is – 2 * X + 2 © John Urrutia 2014, All Rights Reserved9

10. Introduction to Heaps Because Heaps are weakly ordered binary trees Searching for a key is slow O(N) Deleting for a key is slow O(N) Adding the minimum key is fast O(1) since it is always at the end leaf or end of the array. © John Urrutia 2014, All Rights Reserved10

11. Introduction to Heaps Because Heaps are weakly ordered binary trees Removing the maximum key is fast O(1) since it is always at the root or top of the array, but that violates the completeness of the heap Replace the root with the minimum key which is the last entry in the array is fast O(1) since it always at the end, but violates the heap condition The solution: Replace the root with the minimum key Percolate the root node down until it is in the right position © John Urrutia 2014, All Rights Reserved11

12. Heap – Remove Max Key 100 102055 30 45 605070 9080 405 © John Urrutia 2014, All Rights Reserved12

13. Heap – Remove code Deletes the root node (contains the maximum Key ) public Node remove() {Node root = heapArray[0]; heapArray[0] = heapArray[--currentSize]; trickleDown(0); return root; } © John Urrutia 2014, All Rights Reserved13

14. Heap – Remove code Deletes the root node (contains the maximum Key ) public void trickleDown(int index) { int largerChild; Node top = heapArray[index];// save root while (index < currentSize / 2// while node has at least 1 child {int leftChild = 2 * index + 1; int rightChild = leftChild + 1;// find larger child if (rightChild < currentSize &&// (rightChild exists?) heapArray[leftChild].getKey() < heapArray[rightChild].getKey()) largerChild = rightChild; else largerChild = leftChild; if (top.getKey() >= heapArray[largerChild].getKey()) break; heapArray[index] = heapArray[largerChild]; index = largerChild; } // end while heapArray[index] = top;// root to index } © John Urrutia 2014, All Rights Reserved14

15. Introduction to Heaps Inserting a non-minimum Node Searching or finding a node position is O(N) The solution: Place the node after the minimum key at the end of the array Percolate the node up until it is in the right position © John Urrutia 2014, All Rights Reserved15

16. Heap – Insert non-minimum 100 102055 30 45 605070 9080 405 120 © John Urrutia 2014, All Rights Reserved16

17. Introduction to Heaps Copy vs. Swap Swapping involves 3 steps for each node Copying involves 1 Step for each node except the last Copy A to Temp Copy B to A Copy C to B Copy D to C Copy temp to D Copy A to Temp Copy B to A Copy Temp to B Copy B to Temp Copy C to B Copy Temp to C Copy C to Temp Copy D to C Copy Temp to D © John Urrutia 2014, All Rights Reserved17

18. Heap – Insert non-minimum 100 102055 30 45 605070 9080 405 120 © John Urrutia 2014, All Rights Reserved18

19. Heap – Insert code Inserts the last node public Boolean insert(int key) { if (currentSize == maxSize) return false; Node newNode = new Node(key); heapArray[currentSize] = newNode; trickleUp(currentSize++); return true; } // end insert() © John Urrutia 2014, All Rights Reserved19

20. Heap – Insert code Inserts the last node public void trickleUp(int index) { int parent = (index - 1) / 2; Node bottom = heapArray[index]; while (index > 0 && heapArray[parent].getKey() < bottom.getKey()) { heapArray[index] = heapArray[parent]; // move it down index = parent; parent = (parent - 1) / 2; } // end while heapArray[index] = bottom; } // end trickleUp() © John Urrutia 2014, All Rights Reserved20

21. The Heapsort The structure of a heap unexpectedly lends itself to sorting unordered data. Recall in a heap the maximum key is always at the root Hence repeatedly removing the root will return the data in descending sequence. The steps: Insert each item into a heap O(logN) Remove each root item from heap O(logN) Each must be executed N times giving O(N*logN) the same as quicksort © John Urrutia 2014, All Rights Reserved21

22. The Heapsort Efficiency of O(N*logN) (the same as quicksort) is actually longer – more instructions in the loop. Two tricks to improve efficiency Load all array items randomly Trickle-down the root N/2 times © John Urrutia 2014, All Rights Reserved22

23. 15 Element Random Array 05 10 25 90 60 55 15 50 4520 35 40 95 © John Urrutia 2014, All Rights Reserved23 30 65 [00] [01] [02] [03] [04] [05] [06] [07] [08] [09] [10] [11] [12] [13] [14] L0 L3 L2 L1 Heap Levels

24. Trickledown heapsort 05 102590 60 55 155045 2035 4095 © John Urrutia 2014, All Rights Reserved24 30 65 L2 L1 L0

25. Heapsort Array 95 10 25 15 60 35 40 55 4590 65 20 50 © John Urrutia 2014, All Rights Reserved25 30 05 [00] [01] [02] [03] [04] [05] [06] [07] [08] [09] [10] [11] [12] [13] [14] L0 L3 L2 L1 Heap Levels

26. Heapsort – Create Heap & Load with random numbers public static void Main(String[] args) { int size, j; Console.Write("Enter number of items: "); size = int.Parse(Console.ReadLine()); Heap theHeap = new Heap(size); Random rnd = new Random(); for(j=0; j<size; j++) // fill array with { // random nodes int random = (int)rnd.Next(0,100); Node newNode = new Node(random); theHeap.insertAt(j, newNode); theHeap.incrementSize(); } © John Urrutia 2014, All Rights Reserved26

27. Heapsort – Applies the heap rule to the array for(j=size/2-1; j>=0; j--) // make random array into heap theHeap.trickleDown(j); for(j=size-1; j>=0; j--) // remove from heap and { // store at array end Node biggestNode = theHeap.remove(); theHeap.insertAt(j, biggestNode); } Console.Write("Sorted: "); for(int j=0; j<maxSize; j++) { Console.Write(heapArray[j].getKey() + " "); Console.WriteLine(""); } © John Urrutia 2014, All Rights Reserved27

28. Heapsort – Sorted Array 95 102515 60 35 405545 9065 2050 © John Urrutia 2014, All Rights Reserved28 30 05

29. Last Note on Heapsort Although heapsort is slightly less efficient than Quicksort, it makes up for this by being less sensitive to the initial data distribution. Quicksort can slow to O(N 2 ) whereas heapsort remains O(N*logN) regardless of distribution. © John Urrutia 2014, All Rights Reserved29

30. Summary In an ascending-priority queue the item with the largest key is said to have the highest priority. (It’s the smallest item in a descending queue.) A priority queue is an Abstract Data Type (ADT) that offers methods for insertion of data and removal of the largest (or smallest) item. A heap is an efficient implementation of an ADT priority queue. A heap offers removal of the largest item, and insertion, in O(N*logN) time. © John Urrutia 2014, All Rights Reserved30

31. Summary The largest item is always in the root. Heaps do not support ordered traversal of the data, locating an item with a specific key, or deletion. A heap is usually implemented as an array representing a complete binary tree. The root is at index 0 and the last item at index N-1. © John Urrutia 2014, All Rights Reserved31

32. Summary Each node has a key less than its parents and greater than its children. An item to be inserted is always placed in the first vacant cell of the array and then trickled up to its appropriate position. When an item is removed from the root, it’s replaced by the last item in the array, which is then trickled down to its appropriate position. The trickle-up and trickle-down processes can be thought of as a sequence of swaps, but are more efficiently implemented as a sequence of copies. © John Urrutia 2014, All Rights Reserved32

33. Summary The priority of an arbitrary item can be changed. First, its key is changed. Then, if the key was increased, the item is trickled up, but if the key was decreased, the item is trickled down. A heap can be based on a binary tree (not a search tree) that mirrors the heap structure; this is called a treeheap. Algorithms exist to find the last occupied node or the first free node in a treeheap. © John Urrutia 2014, All Rights Reserved33

34. Summary Heapsort is an efficient sorting procedure that requires O(N*logN) time. Conceptually, heapsort consists of making N insertions into a heap, followed by N removals. Heapsort can be made to run faster by applying the trickle-down algorithm directly to N/2 items in the unsorted array, rather than inserting N items. The same array can be used for the initial unordered data, for the heap array, and for the final sorted data. Thus, heapsort requires no extra memory. © John Urrutia 2014, All Rights Reserved34