Intro. to Data Structures Chapter 6 Priority Queue (Heap) Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University 1 Priority Queue (Heap) A kind of queue Dequeue gets element with the highest priority Priority is based on a comparable value (key) of each object (smaller value higher priority, or higher value higher priority) Example Applications: –printer -> print (dequeue) the shortest document first –operating system -> run (dequeue) the shortest job first –normal queue -> dequeue the first enqueued element first

Intro. to Data Structures Chapter 6 Priority Queue (Heap) Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University 2 Priority Queue (Heap) Operations insert (enqueue) deleteMin (dequeue) –smaller value higher priority –find, return, and remove the minimum element Priority Queue insertdeleteMin

Intro. to Data Structures Chapter 6 Priority Queue (Heap) Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University 3 Implementation using Linked List Unsorted linked list –insert takes O(1) time –deleteMin takes O(N) time Sorted linked list –insert takes O(N) time –deleteMin takes O(1) time

Intro. to Data Structures Chapter 6 Priority Queue (Heap) Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University 4 Implementation using Binary Search Tree insert takes O(log N) time deleteMin takes O(log N) time support other operations that are not required by priority queue (for example, findMax) deleteMin make the tree unbalanced

Intro. to Data Structures Chapter 6 Priority Queue (Heap) Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University 5 Binary Heap binary tree completely filled (bottom level is filled from left to right size between 2 h (bottom level has only one node) and 2 h+1 -1 A C G F B E J D HI

Intro. to Data Structures Chapter 6 Priority Queue (Heap) Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University 6 Array Implementation of Binary Heap A C G F B E J D HI ABCDEFGHI J left child is in position 2i right child is in position (2i+1) parent is in position i/2

Intro. to Data Structures Chapter 6 Priority Queue (Heap) Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University 7 Heap Order Property (for Minimum Heap) Any node is smaller than (or equal to) all of its children (any subtree is a heap) Smallest element is at the root (findMin take O(1) time)

Intro. to Data Structures Chapter 6 Priority Queue (Heap) Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University 8 Insert Create a hole in the next available location Move the hole up (swap with its parent) until data can be placed in the hole without violating the heap order property (called percolate up)

Intro. to Data Structures Chapter 6 Priority Queue (Heap) Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University 9 Insert Percolate Up -> move the place to put 14 up (move its parent down) until its parent <= 14 insert 14

Intro. to Data Structures Chapter 6 Priority Queue (Heap) Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University 10 Insert

Intro. to Data Structures Chapter 6 Priority Queue (Heap) Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University 11 deleteMin Create a hole at the root Move the hole down (swap with the smaller one of its children) until the last element of the heap can be placed in the hole without violating the heap order property (called percolate down)

Intro. to Data Structures Chapter 6 Priority Queue (Heap) Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University 12 deleteMin Percolate Down -> move the place to put 31 down (move its smaller child up) until its children >= 31

Intro. to Data Structures Chapter 6 Priority Queue (Heap) Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University 13 deleteMin

Intro. to Data Structures Chapter 6 Priority Queue (Heap) Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University 14 deleteMin

Intro. to Data Structures Chapter 6 Priority Queue (Heap) Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University 15 Running Time insert –worst case: takes O(log N) time, moves an element from the bottom to the top –on average: takes a constant time (2.607 comparisons), moves an element up levels deleteMin –worst case: takes O(log N) time –on average: takes O(log N) time (element that is placed at the root is large, so it is percolated almost to the bottom)

Intro. to Data Structures Chapter 6 Priority Queue (Heap) Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University 16 public class BinaryHeap { private static final int DEFAULT_CAPACITY = 100; private int currentSize; private Comparable [ ] array; public BinaryHeap( ) public BinaryHeap( int capacity ) public void insert( Comparable x ) throws Overflow public Comparable findMin( ) public Comparable deleteMin( )

Intro. to Data Structures Chapter 6 Priority Queue (Heap) Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University 17 public boolean isEmpty( ) public boolean isFull( ) public void makeEmpty( ) private void percolateDown( int hole ) private void buildHeap( ) }

Intro. to Data Structures Chapter 6 Priority Queue (Heap) Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University 18 public static void main( String [ ] args ) { int numItems = 10000; BinaryHeap h = new BinaryHeap( numItems ); int i = 37; for( i = 37; i != 0; i = ( i + 37 ) % numItems ) h.insert( new MyInteger( i ) ); for( i = 1; i < numItems; i++ ) if( ((MyInteger)( h.deleteMin( ) )).intValue( ) != i ) System.out.println( "Oops! " + i ); }

Intro. to Data Structures Chapter 6 Priority Queue (Heap) Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University 19 public BinaryHeap( ) { this( DEFAULT_CAPACITY ); } public BinaryHeap( int capacity ) { currentSize = 0; array = new Comparable[ capacity + 1 ]; } public void makeEmpty( ) { currentSize = 0; }

Intro. to Data Structures Chapter 6 Priority Queue (Heap) Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University 20 public void insert( Comparable x ) throws Overflow { if( isFull( ) ) throw new Overflow( ); int hole = ++currentSize; for( ; hole > 1 && x.compareTo( array[ hole / 2 ] ) < 0; hole /= 2 ) array[ hole ] = array[ hole / 2 ]; array[ hole ] = x; } public Comparable deleteMin( ) { if( isEmpty( ) ) return null; Comparable minItem = findMin( ); array[ 1 ] = array[ currentSize-- ]; percolateDown( 1 ); return minItem; }

Intro. to Data Structures Chapter 6 Priority Queue (Heap) Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University 21 private void percolateDown( int hole ) { int child; Comparable tmp = array[ hole ]; for( ; hole * 2 <= currentSize; hole = child ) { child = hole * 2; if( child != currentSize && array[ child + 1 ].compareTo( array[ child ] ) < 0 ) child++; if( array[ child ].compareTo( tmp ) < 0 ) array[ hole ] = array[ child ]; else break; } array[ hole ] = tmp; }

Intro. to Data Structures Chapter 6 Priority Queue (Heap) Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University 22 public boolean isEmpty( ) { return currentSize == 0; } public boolean isFull( ) { return currentSize == array.length - 1; } private void buildHeap( ) { for( int i = currentSize / 2; i > 0; i-- ) percolateDown( i ); } public Comparable findMin( ) { if( isEmpty( ) ) return null; return array[ 1 ]; }

Intro. to Data Structures Chapter 6 Priority Queue (Heap) Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University 23 Other Operations buildHeap –insert N times decreaseKey(p,  ) –decrease the value of the key and percolate up increaseKey(p,  ) –increase the value of the key and percolate down delete –decreaseKey(p, ฅ  ) and deleteMin( )

Intro. to Data Structures Chapter 6 Priority Queue (Heap) Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University 24 buildHeap insert N times each insert takes O(1) average time, O(log N) worst-case time buildHeap takes O(N) average time, O(N log N) worst-case time

Intro. to Data Structures Chapter 6 Priority Queue (Heap) Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University 25 buildHeap: another method Place N items in to the tree in any order and percolate down every node from bottom up to the root Worst-case time of buildHeap is the sum of worst-case time to percolate these nodes, or the sum of heights of these nodes This method has O(N) worst-case time

Intro. to Data Structures Chapter 6 Priority Queue (Heap) Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University 26 Application: Selection Problem Find the k th smallest element in a list Algorithm A –buildHeap from all elements and deleteMin k times –running time O(N + k log N) –if k = O(N / log N) then running time is O(N) –if k = O(N) then running time is O(N log N) –if k = N and record the values deleted by deleteMin --> heap sort

Intro. to Data Structures Chapter 6 Priority Queue (Heap) Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University 27 Application: Selection Problem Algorithm B (find the k th largest element) –Maintain a set S of k largest elements all the time –buildHeap from first k elements, the k th largest element (the smallest in S, called S k ) is on top –If the next element in the input is larger than S k, then S k is removed and the new one is inserted into S –Running time is O(k) + O(N-k) + O((N-k)log k) = O(N log k)

Intro. to Data Structures Chapter 6 Priority Queue (Heap) Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University 28 Application: Event Simulation Simulation of a bank with k tellers and C customers Each customer causes two events, arrival and departure. Each event has a timestamp Arrival events are put into a queue and departure events are put into a priority queue Find event that should occur next and process it Running time is O(C log(k+1))

Intro. to Data Structures Chapter 6 Priority Queue (Heap) Veera Muangsin, Dept. of Computer Engineering, Chulalongkorn University 29 d-Heaps In a d-heap, all nodes have d children A binary heap is a 2-heap insert takes O(log d N) deleteMin takes O(d log d N)