Heaps Priority Queues

1/6/2016Data Structure: Heaps2 Outline Binary heaps Binomial queues Leftist heaps

Binary Heaps

1/6/2016Data Structure: Heaps4 Heap order property For every root node N, the key in the parent of N is smaller than or equal to the key in N The smallest value is in the root.

1/6/2016Data Structure: Heaps5 Operations on priority queues Insert –Put an element into the queue DeleteMin –Find the minimal element –Return it –Remove it from the queue

1/6/2016Data Structure: Heaps6 Binary Heaps A binary heap is an implementation of a priority queue. A binary heap is a complete binary tree with heap order property.

1/6/2016Data Structure: Heaps7 Complete Binary Tree A binary tree is a complete binary tree if every level in the tree is completely filled, except the leaf level, which is filled from left to right Height is in  log 2 n , where n is the number of nodes.

1/6/2016Data Structure: Heaps8 Array implementation of complete binary tree A B D E I J K H C FG L ABCDIHGFEJ LK

1/6/2016Data Structure: Heaps9 Class BinaryHeap public class BinaryHeap {public BinaryHeap( ) {this( DEFAULT_CAPACITY ); } public BinaryHeap( int capacity ) {currentSize = 0; array = new Comparable[ capacity + 1 ]; } … private static final int DEFAULT_CAPACITY = 100; private int currentSize; // Number of elements in heap private Comparable [ ] array; // The heap array }

1/6/2016Data Structure: Heaps10 percolateUp

1/6/2016Data Structure: Heaps11 Method percolateUp private void percolateUp( int hole ) {Comparable x = array[hole]; while (hole > 1 && x.compareTo( array[ hole / 2 ] ) < 0) {array[ hole ] = array[ hole/2 ]; hole = hole/2; } array[ hole ] = x; }

1/6/2016Data Structure: Heaps12 Method percolateUp private void percolateUp( int hole ) {while (hole>1 && array[hole].compareTo( array[ hole/2 ])<0) {swap(hole, hole/2); hole = hole/2; } private void swap( int p1, int p2 ) {Comparable x = array[p1]; array[p1] = array[p2]; array[p2] = x; }

1/6/2016Data Structure: Heaps13 PercolateDown

1/6/2016Data Structure: Heaps14 Method percolateDown private void percolateDown( int hole ) {int child; while( hole * 2 <= currentSize) {child = hole * 2; if(child != currentSize&&array[ child+1].compareTo( array[child ])<0) child++;// choose the smaller child if( array[ child ].compareTo( array[ hole ] ) < 0 ) swap( hole, child ); else break; hole = child; }

1/6/2016Data Structure: Heaps15 Method percolateDown private void percolateDown( int hole ) {int child; Comparable tmp = array[ hole ]; // save the value of the node while ( hole * 2 <= currentSize ) {child = hole * 2; if(child != currentSize&&array[ child+1].compareTo( array[child ])<0) child++;// choose the smaller child if( array[ child ].compareTo( tmp ) < 0 ) {array[ hole ] = array[ child ];// move child up hole = child; // move hole down } else break; } array[ hole ] = tmp;// put the value in the hole }

1/6/2016Data Structure: Heaps16 Insertion

1/6/2016Data Structure: Heaps17 Method insert public void insert( Comparable x ) throws Overflow {if( isFull( ) )throw new Overflow( ); array[++currentSize]=x; percolateUp(currentSize); }

1/6/2016Data Structure: Heaps18 DeleteMin

1/6/2016Data Structure: Heaps19 Method deleteMin public Comparable findMin( ) {if( isEmpty( ) )return null; return array[ 1 ]; } public Comparable deleteMin( ) {if( isEmpty( ) )return null; Comparable minItem = findMin( ); array[ 1 ] = array[ currentSize--]; percolateDown( 1 ); return minItem; }

1/6/2016Data Structure: Heaps20 Method buildHeap private void buildHeap( ) {for( int i = currentSize / 2; i > 0; i-- ) percolateDown( i ); }

1/6/2016Data Structure: Heaps21 Method decreaseKey public void decreaseKey(int p, Comparable d) throws outOfRange {if( p>currentSize )throw new outOfRange(); array[ p ] = array[ p ] - d; percolateUp( p ); }

1/6/2016Data Structure: Heaps22 Method increaseKey public void increaseKey(int p, Comparable d) throws outOfRange {if( p>currentSize )throw new outOfRange(); array[ p ] = array[ p ] + d; percolateDown( p ); }

Binomial Queues

1/6/2016Data Structure: Heaps24 Binomial Tree A binomial tree is defined recursively as follow: A binomial tree of height 0, denoted by B 0, is a one- node tree. A binomial tree of height k, denoted by B k, is formed by attaching a binomial tree B k-1 to the root of another binomial tree B k-1.

1/6/2016Data Structure: Heaps25 Property of Binomial Trees A binomial tree of height k has 2 k nodes. The number of nodes at depth d is the binomial coefficient  k   d 

1/6/2016Data Structure: Heaps26 Structure A binomial queue is a collection of heap- ordered trees, each of which is a binomial tree

1/6/2016Data Structure: Heaps27 Binomial Nodes class BinomialNode {BinomialNode( Comparable theElement ) { this( theElement, null, null ); } BinomialNode( Comparable theElement, BinomialNode lt, BinomialNode nt ) {element = theElement; Child = lt;nextSibling = nt; } Comparable element; BinomialNode Child; BinomialNode nextSibling; }

1/6/2016Data Structure: Heaps28 Examples: binomial nodes Child nextSibling

1/6/2016Data Structure: Heaps29 Binomial Queues public class BinomialQueue {public BinomialQueue( ) {theTrees = new BinomialNode[ MAX_TREES ]; makeEmpty( );}... public void makeEmpty( ) {currentSize = 0; for( int i=0; i < theTrees.length; i++ ) theTrees[ i ] = null;} private static final int MAX_TREES = 14; private int currentSize; private BinomialNode [ ] theTrees; private int capacity( ) {return 2*theTrees.length - 1;} }

1/6/2016Data Structure: Heaps30 Method combineTrees private static BinomialNode combineTrees ( BinomialNode t1,BinomialNode t2 ) {if( t1.element.compareTo( t2.element ) > 0 ) return combineTrees( t2, t1 ); t2.nextSibling = t1.Child; t1.leftChild = t2; return t1; }

1/6/2016Data Structure: Heaps31 Method merge (1) public void merge( BinomialQueue rhs ) throws Overflow {if( this == rhs ) return; if( currentSize+rhs.currentSize>capacity() ) throw new Overflow( ); currentSize += rhs.currentSize; BinomialNode carry = null; for( int i=0,j=1; j<=currentSize; i++,j*=2 ) {BinomialNode t1 = theTrees[ i ]; BinomialNode t2 = rhs.theTrees[ i ];

1/6/2016Data Structure: Heaps32 Method merge (2) // No trees if (t1==null && t2==null && carry==null) {} // Only this if (t1!=null && t2==null && carry==null) {} // Only rhs if (t1==null && t2!=null && carry==null) {theTrees[i] = t2; rhs.theTrees[i] = null;} // Only carry if (t1==null && t2==null && carry!=null) {theTrees[ i ] = carry; carry = null;} // this & rhs if (t1!=null && t2==null && carry!=null) {carry = combineTrees( t1, t2 ); theTrees[i]=rhs.theTrees[i]=null;}

1/6/2016Data Structure: Heaps33 Method merge (3) // this and carry if (t1!=null && t2==null && carry!=null) {carry = combineTrees( t1, carry ); theTrees[ i ] = null;} // rhs and carry if (t1==null && t2!=null && carry!=null) {carry = combineTrees( t2, carry ); rhs.theTrees[ i ] = null;} // All three if (t1!=null && t2!=null && carry!=null) {theTrees[ i ] = carry; carry = combineTrees( t1, t2 ); rhs.theTrees[ i ] = null;} }

1/6/2016Data Structure: Heaps34 Method merge (4) for( int k=0; k < rhs.theTrees.length; k++ ) rhs.theTrees[ k ] = null; rhs.currentSize = 0; }

1/6/2016Data Structure: Heaps35 Method insert public void insert( Comparable x ) throws Overflow {BinomialQueue oneItem= new BinomialQueue( ); oneItem.currentSize = 1; oneItem.theTrees[0] = new BinomialNode( x ); merge( oneItem ); }

1/6/2016Data Structure: Heaps36 Method deleteMin (2) for( int j = minIndex - 1; j >= 0; j-- ) {deletedQueue.theTrees[ j ] = deletedTree; deletedTree = deletedTree.nextSibling; deletedQueue.theTrees[ j ].nextSibling = null; } theTrees[ minIndex ] = null; currentSize -= deletedQueue.currentSize + 1; try { merge( deletedQueue ); } catch( Overflow e ) { } return minItem; }

1/6/2016Data Structure: Heaps37 Method deleteMin public Comparable deleteMin( ) {if( isEmpty( ) )return null; int minIndex = findMinIndex( ); Comparable minItem = theTrees[minIndex].element; BinomialNode deletedTree = theTrees[ minIndex ].child; BinomialQueue deletedQueue = new BinomialQueue( ); deletedQueue.currentSize =(1 << minIndex)-1;

Leftist Heaps

1/6/2016Data Structure: Heaps39 Null Path Length The null path length of the node X, npl(X), is the length of the shortest path from X to a node without 2 children. npl(X) = 1 + min (npl(Y 1 ), npl(Y 2 )), where Y 1 and Y 2 are children of X

1/6/2016Data Structure: Heaps40 Leftist Trees A leftist tree is a binary tree such that for every node X in the tree npl(left)  npl(right), where left and right are left child and right child of X

1/6/2016Data Structure: Heaps41 Examples of leftist trees

1/6/2016Data Structure: Heaps42 Leftist Heap A leftist heap is a leftist tree with heap order property

1/6/2016Data Structure: Heaps43 Leftist Tree Nodes class LeftHeapNode {LeftHeapNode( Comparable theElement ) {this( theElement, null, null );} LeftHeapNode( Comparable theElement, LeftHeapNode lt, LeftHeapNode rt ) {element = theElement; npl = 0; left = lt;right = rt;} Comparable element; int npl; LeftHeapNode left;LeftHeapNode right; }

1/6/2016Data Structure: Heaps44 Merge Leftist Heaps

1/6/2016Data Structure: Heaps45 Merge Leftist Heaps

1/6/2016Data Structure: Heaps46 Merge Leftist Heaps

1/6/2016Data Structure: Heaps47 Method merge1 private static LeftHeapNode merge1 ( LeftHeapNode h1, LeftHeapNode h2 ) {if( h1.left == null ) // Single node h1.left = h2; // Other fields in h1 OK else {h1.right = merge( h1.right, h2 ); if( h1.left.npl < h1.right.npl ) swapChildren( h1 ); h1.npl = h1.right.npl + 1; } return h1; }

1/6/2016Data Structure: Heaps48 Method merge public void merge( LeftistHeap rhs ) {if( this == rhs ) return; root = merge( root, rhs.root ); rhs.root = null; } private static LeftHeapNode merge( LeftHeapNode h1, LeftHeapNode h2 ) {if( h1 == null ) return h2; if( h2 == null ) return h1; if( h1.element.compareTo( h2.element ) < 0 ) return merge1( h1, h2 ); else return merge1( h2, h1 ); }

1/6/2016Data Structure: Heaps49 Methods insert, deleteMIn public void insert( Comparable x ) {root=merge(new LeftHeapNode(x),root); } public Comparable deleteMin( ) {if( isEmpty( ) )return null; Comparable minItem = root.element; root = merge( root.left, root.right ); return minItem; }

1/6/2016Data Structure: Heaps50 Applications Event simulation Merge sort

1/6/2016Data Structure: Heaps51 Event Simulation Events have the scheduled time to happen. Advancing time by clock ticks is too slow. We need to find the “next” event. So, events are put into heaps with time as the element. We choose the next event from the root of the heapp.

1/6/2016Data Structure: Heaps52 Heap Sort

1/6/2016Data Structure: Heaps53 Heap Sort

1/6/2016Data Structure: Heaps54 Heap Sort

1/6/2016Data Structure: Heaps55 Heap Sort

1/6/2016Data Structure: Heaps56 Heap Sort

1/6/2016Data Structure: Heaps57