data ordered along paths from root to leaf Heaps data ordered along paths from root to leaf

Heaps and applications what is a heap? how is a heap implemented? using a heap for a priority queue using a heap for sorting

Heap definition Complete binary tree with data ordered so that data value in a node always precedes data in child nodes 30 20 28 16 19 26 26 14 8 17 18 24 11 example: integer values in descending order along path from root blue node is only possible removal location red node is only possible insertion location

Heap storage An array is the ideal storage for a complete binary tree 1 2 3 30 20 28 16 19 26 26 14 8 17 18 24 level 0 1 2 3 / 30 20 28 16 19 26 26 14 8 17 18 24 a size 12

Heap implementation / Assuming 0th element of array is unused, root node is at index 1 for node at index i: parent node is at i/2 child nodes are at 2i and 2i+1 last node is at index size 30 28 20 16 14 8 19 17 18 26 24 1 2 3 level 0 1 2 3 / 30 20 28 16 19 26 26 14 8 17 18 24 a 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 size 12

implementation in an ADT: array and size Comparable[] a; int size; private boolean full() { // first element of array is empty return (size == a.length-1); }

Heap operations Insertion and deletion maintain the complete tree AND maintain the array with no ‘holes’ 30 20 28 16 19 26 26 14 8 17 18 24 43 30 20 28 16 19 26 26 14 8 17 18 24 43 a size 12

Heap operations - terminology heapify – reorganize data in an array so it is a heap reheapify – reorganize data in a heap with one data item out of order reheapify down – when data at root is out of order reheapify up – when last data item is out of order

Heap operations - insertion insert new data item after last current data if necessary, ‘reheapify’ up 30 20 28 16 19 26 26 14 8 17 18 24 29 30 20 28 16 19 26 26 14 8 17 18 24 29 a 13 size 12

Heap operations - insertion insert new data item after last current data if necessary, ‘reheapify’ up 30 29 20 28 28 16 19 26 26 26 14 8 17 18 24 29 29 28 26 30 20 28 16 19 26 26 14 8 17 18 24 29 a size 13

implementation in an ADT: insertion public void add(Comparable data) { if (full()) // expand array ensureCapacity(2*size); size++; a[size] = data; if (size > 1) heapifyUp(); }

implementation in an ADT: heapifyUp private void heapifyUp() { Comparable temp; int next = size; while (next != 1 && a[next].compareTo(a[next/2]) > 0) temp = a[next]; a[next] = a[next/2]; a[next/2] = temp; next = next/2; }

Heap operations - deletion only the item at the root can be removed delete the root data and replace with the last data item if necessary, ‘reheapify’ down 24 30 20 28 16 19 26 26 14 8 17 18 24 24 30 20 28 16 19 26 26 14 8 17 18 24 a size 12 11

Heap operations - deletion only the item at the root can be removed delete the root data and replace with the last data item if necessary, ‘reheapify’ down 28 24 26 20 28 16 19 26 24 26 14 8 17 18 28 26 24 24 20 28 16 19 26 26 14 8 17 18 a size 11

implementation in an ADT: deletion public Comparable removeMax() { if (size == 0) throw new IllegalStateException(“empty heap”); Comparable max = a[1]; a[1] = a[size]; size--; if (size > 1) heapifyDown(1); return max; }

implementation in an ADT: heapifyDown private void heapifyDown(int root) { Comparable temp; int next = root; while (next*2 <= size) // node has a child int child = 2*next; // left child if (child < size && a[child].compareTo(a[child+1]) < 0) child++; // right child instead if (a[next].compareTo(a[child]) < 0) temp = a[next]; a[next] = a[child]; a[child] = temp; next = child; } else; next = size; // stop loop

Heap operations – ‘heapify’ make a heap from an unsorted array buildHeap() recursive construction of a heap: (post-order traversal) heapify left subtree heapify right subtree send root to correct position using reheapifyDown() 3 1 2

implementation in an ADT: heapify an array - recursive public void heapify () { heapify(1); } private void heapify(int root) if(root > size/2) return; //no children heapify(root*2); // left subtree if (root*2+1 <=size) heapify(root*2+1); // right subtree heapifyDown(root); // do root node

Heap operations – ‘heapify’ iterative construction of a heap: (bottom-up) – O(n) the leaves are already (one node) heaps start at second row from bottom-heapifyDown() row by row to row 0 (root) leaves

implementation in an ADT: heapify an array - iterative public void heapify () { for (int next = size/2; next>=1; next--) heapifyDown(next); }

Heap application priority queue implementation insert (enqueue) these operations fit the requirements of the priority queue with O(log n) performance priority queue implementation insert (enqueue) delete min (dequeue) unsorted array O(1) O(n) sorted array unsorted linked list sorted linked list binary heap O(log n)

Heap application - sorting Heapsort in place sorting in O(n log n) time two stage procedure: unsorted array -> heap -> sorted array 1 2 build heap repeat [delete maximum ]

Heap application - sorting heap must be ordered opposite to final result e.g., for ascending order sort, heap must be descending order basic operation of second stage: heap sorted m x m x m x x m remove max item in heap (m); last item gets moved to top last item gets heapified down put m in vacant space after heap

implementation in an ADT: heapsort public void heapsort() { heapify(); int keepSize = size; for (int next = 1; next <= keepSize; next++) Comparable temp = removeMax(); a[size+1] = temp; } size = keepSize;

Huffman coding with a heap Huffman codes are based on a binary tree Left branch coded 0 Right branch coded 1 Coded characters are in leaves Example Codes a 1 b 010 c 0001 d 0000 x 011 y 001 1 a 1 1 1 1 y b x d c

Building the tree Based on frequencies of characters - Make heap (lowest first) Example Frequencies a 125 b 15 c 4 d 3 x 17 y 12 3 d 12 y 4 c 17 x 125 a 15 b

Building the tree Remove two lowest from heap 4 c 3 d 17 x 12 y Remove two lowest from heap Make a tree with each as a subtree – add frequencies for root Put tree in heap by root frequency 3 d 125 a 15 b 4 c 17 x 12 y 4 c 15 b 12 y 125 a 17 x 7 12 y 15 b 125 a 17 x 3 d 4 c

Building the tree Remove two lowest from heap 12 y 17 x 15 b 4 c 3 d 7 Remove two lowest from heap Make a tree with each as a subtree Put tree in heap by total frequency Repeat until all in one tree . . . 17 x 12 y 125 a 15 b 4 c 3 d 7 19 19 125 a 32 12 y 15 b 17 x 7 3 d 4 c

Building the tree Remove two lowest from heap 19 125 a 32 Remove two lowest from heap Make a tree with each as a subtree Put tree in heap by total frequency Repeat until all in one tree . . . 12 y 15 b 17 x 7 3 d 4 c 51 125 a 19 32 7 12 y 15 b 17 x 3 d 4 c

Building the tree Remove two lowest from heap 51 125 a Remove two lowest from heap Make a tree with each as a subtree Put tree in heap by total frequency Repeat until all in one tree . . . 19 32 7 12 y 15 b 17 x 3 d 4 c 176 51 125 a 19 32 7 12 y 15 b 17 x 3 d 4 c

Translating the tree Make table from tree Example Codes a 1 b 010 176 Make table from tree Example Codes a 1 b 010 c 0001 d 0000 x 011 y 001 51 125 a 19 32 7 12 y 15 b 17 x 3 d 4 c

Using the Huffman coding b 010 c 0001 d 0000 x 011 y 001 To encode, use table: day  00001001 To decode, use tree 00001001  day a 1 d c y b x