Build Heap and Heap Sort CS 261 – Data Structures Build Heap and Heap Sort

Building a Heap At the beginning, only the leaves are proper heaps: void buildHeap(struct DynArr *arr) { int max = sizeDynArr(arr); /* All nodes greater than max/2 - 1 are leaves and thus adhere to the heap property! */ for (int i = max / 2 - 1; i >= 0; i--) _adjustHeap(max, i); /* Make subtree rooted at i a heap. */ } At the beginning, only the leaves are proper heaps: Leaves are all nodes with indices greater than max / 2 At each step, the subtree rooted at index i becomes a heap

Heap Implementation: Build heap void buildHeap(struct DynArr *arr) { int max = sizeDynArr(arr); /* All nodes greater than max/2 - 1 are leaves and thus adhere to the heap property! */ for (int i = max / 2 - 1; i >= 0; i--) _adjustHeap(max, i); /* Make subtree rooted at i a heap. */ } For all subtrees that are are not already heaps (initially, all inner, or non-leaf, nodes): Call _adjustHeap with the largest node index that is not already guaranteed to be a heap Iterate until the root node becomes a heap Why call _adjustHeap with the largest non-heap node? Because its children, having larger indices, are already guaranteed to be heaps

Heap Implementation: Build heap (cont.) 12 First iteration: adjust largest non-leaf node (index 4) 7 5 adjustHeap 8 3 7 4 i (max/2-1) 9 11 10 2 max 12 1 7 2 5 3 8 4 3 5 7 6 4 7 9 8 11 9 10 10 2 11 Already heaps (leaf nodes)

Heap Implementation: Build heap (cont.) 12 Second iteration: adjust largest non-heap node (index 3) 7 5 adjustHeap 8 2 7 4 9 11 10 3 i (no adjustment needed) max 12 1 7 2 5 3 8 4 2 5 7 6 4 7 9 8 11 9 10 10 3 11 Already heaps

Heap Implementation: Build heap (cont.) 12 Third iteration: adjust largest non-heap node (index 2) 7 5 adjustHeap 8 2 7 4 9 11 10 3 i max 12 1 7 2 5 3 8 4 2 5 7 6 4 7 9 8 11 9 10 10 3 11 Already heaps

Heap Implementation: Build heap (cont.) 12 Fourth iteration: adjust largest non-heap node (index 1) adjustHeap 7 4 8 2 7 5 9 11 10 3 max 12 1 7 2 4 3 8 4 2 5 7 6 5 7 9 8 11 9 10 10 3 11 Already heaps i

Heap Implementation: Build heap (cont.) 12 Fifth iteration: adjust largest non-heap node (index 0  root) adjustHeap 2 4 8 3 7 5 9 11 10 7 max 12 1 2 2 4 3 8 4 3 5 7 6 5 7 9 8 11 9 10 10 7 11 Already heaps i

Heap Implementation: Build heap (cont.) 2 3 4 8 7 7 5 9 11 10 12 2 1 3 2 4 3 8 4 7 5 7 6 5 7 9 8 11 9 10 10 12 Already heaps (entire tree)

Heap Sort: Implementation void heapSort(struct DynArr *arr) { /* Sorts data in reverse order. */ int i = sizeDynArr(arr); buildHeap(arr); /* Build initial heap. */ while (--i > 0) { /* For each of the n elements: */ swap(arr, 0, i); /* Swap first (smallest) and last (ith) elements. */ _adjustHeap(data, i, 0); /* Rebuild heap property. */ } Sorts the data in descending order (from largest to smallest): Builds heap from initial (unsorted) data Iteratively swaps the smallest element (at index 0) with last unsorted element Adjust the heap after each swap, but only considers the unsorted data

Heap Sort: View During Execution

Heap Sort: Algorithmic Complexity Execution time: Build heap: n calls to _adjustHeap = n log n Loop: n calls to _adjustHeap = n log n Total: 2n log n = O(n log n) Advantages/disadvantages: Same average as merge sort and quick sort Doesn’t require extra space as the merge sort does Doesn’t suffer if data is already sorted or mostly sorted

Your Turn Lesson 23: Build Heaps and Heap Sort