Priority Queues. Priority Queues and Binary Heaps. Priority queues. Priority queue ADT. The priority queue interface.

Transcription

1 Priority Queues and Binary Heaps 5- Fundamental Data Structures and Algorithms Peter Lee February, 00 Announcements HW is available due Monday, Feb.0, :5pm start today! Quiz # available Thursday an online quiz requires up to one hour of uninterrupted time with a web browser must be completed by Friday, :5pm HW in teams of two go to recitation for details Priority queues Today we consider a useful abstract data type called the priority queue. Priority Queues Priority queue ADT Assume we have objects x that can be compared using the < and == operators. These are Comparable objects. insert(k, o) Inserts comparable object k into the priority queue with object o. deletemin() Returns and removes the minimum element from the priority queue. The priority queue interface create insert void insert (Comparable key, Object r) findmin Comparable findmin () deletemin Comparable deletemin ()

2 Priority Queues: Applications Event simulations (key is time) Shortest paths in a graph Huffman codes Sorting Possible priority queue implementations Linked list deletemin O() O(N) insert O(N) or O() Search trees All operations O(log N) Heaps avg (assume random) worst deletemin O(log N) O(log N) insert.6 O(log N) special case: buildheap O(N) O(N) i.e., insert*n Possible priority queue implementations Linked list deletemin O() O(N) insert O(N) or O() Search trees All operations O(log N) Heaps avg (assume random) worst deletemin O(log N) O(log N) insert.6 O(log N) special case: buildheap O(N) O(N) i.e., insert*n Possible priority queue implementations Linked list deletemin O() O(N) insert O(N) or O() Search trees All operations O(log N) Heaps avg (assume random) worst deletemin O(log N) O(log N) insert.6 O(log N) special case: buildheap O(N) O(N) i.e., insert*n A Digression: Perfect and Complete Binary Trees

3 How many nodes? How many nodes? N = - = 5 h= N=5 How many nodes? N = - = 5 Most of the nodes are How many nodes? N = - = 5 Most of the nodes are leaves How many edges? h= N=5 h= N=5

4 How many nodes? N = - = 5 How many nodes? N = - = 5 In general: N = In general: N = = h+ - Most of the nodes are leaves Most of the nodes are leaves h= N=5 h= N=5 Red-green quiz Quiz Break In a perfect binary tree, what is the sum of the heights of the nodes? Give a mathematical characterization. Give a tight upper bound (in big-o terms) Complete binary trees What is the sum of the heights? S = < N = O(N) h= N=5

5 Complete binary trees Linked structures? 0 0 Linked structures? No! Instead, use arrays! Arrays Parent at position i in the array Children at positions i and i+ 0 0 Arrays (-based) Parent at position i Children at i and i+. 0 Arrays (-based) Parent at position i Children at i and i

6 Arrays (-based) Parent at position i Children at i (and i+). 0 0 Arrays (-based) Parent at position i Children at i and i+. public class BinaryHeap { private Comparable[] heap; private int size; public BinaryHeap(int capacity) { size=0; heap = new Comparable[capacity+];... Arrays Parent at position i Children at i and i+. Example: find the leftmost child int left=; for(; left<size; left*=); return heap[left/]; Example: find the rightmost child int right=; for(; right<size; right=right*+); return heap[(right-)/]; Back to Our Main Topic: Implementing Priority Queues with Binary Heaps Binary heaps: the invariant Representation invariants. Structure property Complete binary tree (i.e. the elements of the heap are stored in positions size of the array). Heap order property Parent keys less than children keys Heaps Representation invariant. Structure property Complete binary tree Hence: efficient compact representation. Heap order property Parent keys less than children keys Hence: rapid insert, findmin, and deletemin O(log(N)) for insert and deletemin O() for findmin 6

7 The heap order property Each parent is less than each of its children. Hence: Root is less than every other node. (obvious proof by induction) Operating with heaps Representation invariant: All methods must:. Produce complete binary trees. Guarantee the heap order property All methods may assume. The tree is initially complete binary. The heap order property holds Constructor method All methods must:. Produce complete binary trees Trivially true. Guarantee the heap order property Also trivially true This is the base case findmin () The code public boolean isempty() { return size == 0; public Comparable findmin() { if(isempty()) return null; return heap[]; Does not change the tree Trivially preserves the invariant insert (Comparable x) Process. Create a hole at the next tree cell for x. heap[size+] This preserves the completeness of the tree.. Percolate the hole up the tree until the heap order property is satisfied. This assures the heap order property is satisfied. insert (Comparable x) Process. Create a hole at the next tree cell for x. heap[size+] This preserves the completeness of the tree assuming it was complete to begin with.. Percolate the hole up the tree until the heap order property is satisfied. This assures the heap order property is satisfied assuming it held at the outset. 7

8 Percolation up public void insert(comparable x) throws Overflow { if(isfull()) throw new Overflow(); int hole = ++size; for(; hole> && x.compareto(heap[hole/])<0; hole/=) heap[hole] = heap[hole/]; heap[hole] = x; Percolation up Bubble the hole up the tree until the heap order property is satisfied. hole = HOP false Not really there... Percolation up Bubble the hole up the tree until the heap order property is satisfied. Percolation up Bubble the hole up the tree until the heap order property is satisfied. hole = hole = 5 HOP false HOP false hole = 5 hole = HOP false HOP true done Percolation up public void insert(comparable x) throws Overflow { if(isfull()) throw new Overflow(); int hole = ++size; for(; hole> && x.compareto(heap[hole/])<0; hole/=) heap[hole] = heap[hole/]; heap[hole] = x; Integer division deletemin() /** * Remove the smallest item from the priority queue. the smallest item, or null, if empty. */ public Comparable deletemin( ) { if(isempty()) return null; Comparable min = heap[]; heap[] = heap[size--]; percolatedown(); return min; Grab min element Temporarily place last element at top!!!

9 Percolation down Bubble the transplanted leaf value down the tree until the heap order property is satisfied. Percolation down Bubble the transplanted leaf value down the tree until the heap order property is satisfied. -- Percolation down Bubble the transplanted leaf value down the tree until the heap order property is satisfied. done percolatedown(int hole) private void percolatedown( int hole ) { int child = hole; Initially Comparable tmp = heap[hole]; for( ; hole* <= size; hole=child ) { Start at left child child = hole * ; Is there a right child? if(child!=size && heap[child+].compareto(heap[child]) < 0) child++; Select smaller child if(array[child].compareto(tmp) < 0) heap[hole] = heap[child]; else break; Bubble up if smaller than tmp heap[hole] = tmp; Exit loop if not bubbling Finally, place the orphan deletemin () Observe that both components of the representation invariant are preserved by deletemin.. Completeness The last cell ( heap[size] ) is vacated, providing the value to percolate down. This assures that the tree remains complete.. Heap order property deletemin () Observe that both components of the representation invariant are preserved by deletemin.. Completeness The last cell ( heap[size] ) is vacated, providing the value to percolate down. This assures that the tree remains complete.. Heap order property

10 deletemin () Observe that both components of the representation invariant are preserved by deletemin.. Completeness The last cell ( heap[size] ) is vacated, providing the value to percolate down. This assures that the tree remains complete.. Heap order property The percolation algorithm assures that the orphaned value is relocated to a suitable position. buildheap() Start with complete (unordered) tree Starting from bottom, repeatedly call percolatedown() Void buildheap () { for (int i = size/; i>0; i--) percolatedown(i); buildheap() performance At each iteration, have to do work proportional to the height of the current node Therefore, total running time is bounded by the sum of the heights of all of the nodes Another Digression: Invariants Representation Invariants (Invariants) Necessary for a clear understand an algorithm or piece of code. The most useful kind of comment you can make in a piece of code! Plus ça change, plus c est la même chose The role of an induction hypothesis 0

11 (Invariants and induction) Induction hypothesis What you are allowed to assume At the start About the result values of a recursive call About the object state when a method is called What you must deliver At the end Of the result values when the recursive call returns About the object state when the method returns (Invariants and induction) Induction hypothesis What you are allowed to assume At the start of a loop iteration About the result values of a recursive call About the object state when a method is called What you must deliver At the end of the loop iteration Of the result values when the recursive call returns About the object state when the method returns (Invariants and induction) Induction hypothesis What you are allowed to assume About the result values of a recursive call About the object state when a method is called What you must deliver Of the result values when the recursive call returns About the object state when the method returns (Invariants and induction) Induction hypothesis What you are allowed to assume At the start of a loop iteration About the result values of a recursive call About the object state when a method is called What you must deliver At the end of the loop iteration Of the result values when the recursive call returns About the object state when the method returns (Invariants and induction) Induction hypothesis What you are allowed to assume At the start of a loop iteration About the result values of a recursive call About the object state when a method is called What you must deliver At the end of the loop iteration Of the result values when the recursive call returns About the object state when the method returns (Invariants) Plus ça change, plus c est la même chose The role of an induction hypothesis Invariants in programs Loop invariants Recursion invariants Representation invariants

12 (Representation invariant) What must always be true of the data structure when an operation completes. Theorem: Suppose each constructor assures the representation invariant is initially correct. Suppose each method preserves the representation invariant, assuming it is true initially. Then the representation invariant will always be true at the completion of each method. (Representation invariant) What must always be true of the data structure when an operation completes. Theorem: Suppose each constructor assures the representation invariant is initially correct. Suppose each method preserves the representation invariant, assuming it is true initially. Then the representation invariant will always be true at the completion of each method. (Representation invariants) What must always be true of the data structure when an operation completes. Theorem: Suppose each constructor assures the representation invariant is initially correct. Suppose each method preserves the representation invariant, assuming it is true initially. Then the representation invariant will always be true at the completion of each method. Assuming the code is not concurrent! Heapsort Obviously we can use a priority queue to sort... just insert all the keys then do repeated deletemins However we can take advantage of the fact that the heap always uses the first part of the array to do this with no extra space. This is called heapsort. Heapsort Reverse the sense of the heap order (largest at the root) Start from position 0 in the array (children are i+ and i+) Call it percdown(a, i, len) Public static void heapsort(comparable[] a) { for(int i = a.length/; i>=0; i--) percdown(a, i, a.length); for (int j = a.length-; j>0; j--) { swapreferences(a, 0, j); percdown(a, 0, j); Heapsort invariant At the start of the loop over j: a[j] a[a.length-] are sorted a[0] a[j-] are a heap