CSCE 3100 Data Structures and Algorithm Analysis Heaps Reading: Chap.6 Weiss

Heaps A heap is a binary tree T that stores a key-element pairs at its internal nodes It satisfies two properties: MinHeap: key(parent)  key(child) [OR MaxHeap: key(parent) >= key(child)] all levels are full, except the last one, which is left-filled

What are Heaps Useful for? To implement priority queues Priority queue = a queue where all elements have a “priority” associated with them Remove in a priority queue removes the element with the smallest priority insert removeMin

Heap or Not a Heap?

Heap Properties A heap T storing n keys has height h = log(n + 1), which is O(log n)

ADT for Min Heap objects: n > 0 elements organized in a binary tree so that the value in each node is at least as large as those in its children method: Heap Create(MAX_SIZE)::= create an empty heap that can hold a maximum of max_size elements Boolean HeapFull(heap, n)::= if (n==max_size) return TRUE else return FALSE Heap Insert(heap, item, n)::= if (!HeapFull(heap,n)) insert item into heap and return the resulting heap else return error Boolean HeapEmpty(heap, n)::= if (n>0) return FALSE else return TRUE Element Delete(heap,n)::= if (!HeapEmpty(heap,n)) return one instance of the smallest element in the heap and remove it from the heap else return error

Heap Insertion Insert 6

Heap Insertion Add key in next available position

Heap Insertion Begin Unheap

Heap Insertion

Heap Insertion Terminate unheap when reach root key child is greater than key parent

Heap Removal Remove element from priority queues? removeMin( )

Heap Removal Begin downheap

Heap Removal

Heap Removal

Heap Removal Terminate downheap when reach leaf level key child is greater than key parent

Bottom-up Heap Construction We can construct a heap storing n given keys using a bottom-up construction with log n phases In phase i, pairs of heaps with 2i -1 keys are merged into heaps with 2i+1-1 keys 2i -1 2i+1-1

Merging Two Heaps We are given two two heaps and a key k 3 5 8 2 6 4 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 heapDown to restore the heap-order property 7 3 2 8 5 4 6 2 3 4 8 5 7 6

Merging Example Insert 16, 15, 4, 12, 6, 9, 23, 20 25 15 16 5 12 4 11 9 6 27 20 23

Example (contd.) heapDown 25 15 16 5 12 4 11 9 6 27 20 23 15 25 16 4

Example (contd.) Insert 7, 8 heapDown 7 15 25 16 4 12 5 8 6 9 11 23 20 27 heapDown 4 15 25 16 5 12 7 6 8 9 11 23 20 27

Example (end) Insert 10 heapDown 4 15 25 16 5 12 7 10 6 8 9 11 23 20 27 heapDown 5 15 25 16 7 12 10 4 6 8 9 11 23 20 27

Bottom up Heap Construction 16 15 4 12 6 7 23 20 25 5 11 27 9 8 14 16 4 15 12 6 7 23 20 25 5 11 27 9 8 14

Bottom up Heap Construction 16 15 4 12 6 7 8 20 25 5 11 27 9 23 14

Bottom up Heap Construction 16 15 4 12 6 7 8 20 25 5 11 27 9 23 14

Bottom up Heap Construction 16 15 4 12 5 7 8 20 25 6 11 27 9 23 14

Bottom up Heap Construction 16 15 4 12 5 7 8 20 25 6 11 27 9 23 14

Bottom up Heap Construction 16 15 4 12 5 7 8 20 25 6 11 27 9 23 14

Bottom up Heap Construction 16 5 4 12 6 7 8 20 25 15 11 27 9 23 14

Bottom up Heap Construction 4 5 7 12 6 9 8 20 25 15 11 27 16 23 14

Heap Implementation Using arrays Parent = k ; Children = 2k , 2k+1 Why is it efficient? 6 12 7 19 18 9 10 30 31 [1] [2] [3] [5] [6] [4] [4]

Insertion into a Heap 2k-1=n ==> k=log2(n+1) O(log2n) void insertHeap(element item, int *n) { int i; if (HEAP_FULL(*n)) { fprintf(stderr, “the heap is full.\n”); exit(1); } i = ++(*n); while ((i!=1)&&(item.key<heap[i/2].key)) { heap[i] = heap[i/2]; i /= 2; heap[i]= item; 2k-1=n ==> k=log2(n+1) O(log2n)

Deletion from a Heap element deleteHeap(int *n) { int parent, child; element item, temp; if (HEAP_EMPTY(*n)) { fprintf(stderr, “The heap is empty\n”); exit(1); } /* save value of the element with the highest key */ item = heap[1]; /* use last element in heap to adjust heap */ temp = heap[(*n)--]; parent = 1; child = 2;

Deletion from a Heap (cont’d) while (child <= *n) { /* find the smaller child of the current parent */ if ((child < *n)&& (heap[child].key>heap[child+1].key)) child++; if (temp.key <= heap[child].key) break; /* move to the next lower level */ heap[parent] = heap[child]; parent = child; child *= 2; } heap[parent] = temp; return item;

Heap Sorting Step 1: Build a heap Step 2: removeMin( ) Running time?