1. Heaps
Priority Queues

2. Outline Binary heaps Binomial queues Leftist heaps 1/17/2019
Data Structure: Heaps

3. Binary Heaps

4. 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. 5 12 19 15 22 25 48 21 16 28 23 27
The smallest value is in the root.
1/17/2019
Data Structure: Heaps

5. Operations on priority queues
Insert
Put an element into the queue
DeleteMin
Find the minimal element
Return it
Remove it from the queue
1/17/2019
Data Structure: Heaps

6. 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/17/2019
Data Structure: Heaps

7. 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. 32
Height is in log2 n,
where n is the
number of nodes. 12 23 34 25 31 33 43 40 56 40 35 30 36 45
1/17/2019
Data Structure: Heaps

8. Array implementation of complete binary tree1 2 3 B C 4 5 6 7 D E F G 8 9 10 11 12 H I J K L A B C D E F G H I J K L
1/17/2019
Data Structure: Heaps

9. 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/17/2019
Data Structure: Heaps

10. percolateUp 5 12 19 15 48 22 25 21 16 23 27 3 36
1/17/2019
Data Structure: Heaps

11. 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/17/2019
Data Structure: Heaps

12. 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/17/2019
Data Structure: Heaps

13. PercolateDown 32 12 23 34 25 31 33 36 45 43 40 56 40 35 30
1/17/2019
Data Structure: Heaps

14. 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/17/2019
Data Structure: Heaps

15. 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/17/2019
Data Structure: Heaps

16. Insertion 5 12 19 15 22 48 25 21 16 28 23 27 10
1/17/2019
Data Structure: Heaps

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

18. DeleteMin 5 12 10 15 22 19 48 21 16 28 23 27 25
1/17/2019
Data Structure: Heaps

19. Method deleteMin public Comparable findMin( )
{ if( isEmpty( ) ) return null;
return array[ 1 ]; }
public Comparable deleteMin( )
Comparable minItem = findMin( );
array[ 1 ] = array[ currentSize--];
percolateDown( 1 );
return minItem;
1/17/2019
Data Structure: Heaps

20. Method buildHeap
private void buildHeap( )
{ for( int i = currentSize / 2; i > 0; i-- )
percolateDown( i ); } 32 12 23 34 25 31 33 36 45 43 40 56 40 35 30
1/17/2019
Data Structure: Heaps

21. 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/17/2019
Data Structure: Heaps

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

23. Binomial Queues

24. Binomial Tree A binomial tree is defined recursively as follow:
A binomial tree of height 0, denoted by B0, is a one-node tree.
A binomial tree of height k, denoted by Bk, is formed by attaching a binomial tree Bk-1 to the root of another binomial tree Bk-1.
1/17/2019
Data Structure: Heaps

25. Property of Binomial Trees
A binomial tree of height k has 2k nodes.
The number of nodes at depth d is the binomial coefficient  k
d. 1
1 1
1 2 1 1 1 1 2 1 4 6 1 3
1/17/2019
Data Structure: Heaps

26. Structure
A binomial queue is a collection of heap-ordered trees, each of which is a binomial tree. 13 16 32 40 26 28 35 43 45 51 46 50 6 3 21
1/17/2019
Data Structure: Heaps

27. 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/17/2019
Data Structure: Heaps

28. Examples: binomial nodes13 13 16 32 40
Child 16 32
nextSibling 40 26 26 28 35 43 45 51 46 50 28 35 45 43 51 46 50
1/17/2019
Data Structure: Heaps

29. 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/17/2019
Data Structure: Heaps

30. 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; } 26 26 28 35 45 28 35 45 43 51 46 43 51 46 50 50
1/17/2019
Data Structure: Heaps

31. 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/17/2019
Data Structure: Heaps

32. 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/17/2019
Data Structure: Heaps

33. 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 ); }
1/17/2019
Data Structure: Heaps

34. Method merge (4) for( int k=0; k < rhs.theTrees.length; k++ )
rhs.theTrees[ k ] = null;
rhs.currentSize = 0; }
1/17/2019
Data Structure: Heaps

35. 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/17/2019
Data Structure: Heaps

36. 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/17/2019
Data Structure: Heaps

37. 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;
1/17/2019
Data Structure: Heaps

38. Leftist Heaps

39. 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(Y1), npl(Y2)), where Y1 and Y2 are children of X. 1 1 1
1/17/2019
Data Structure: Heaps

40. 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 1 1
1/17/2019
Data Structure: Heaps

41. Examples of leftist trees1 1 1 1 1 1 1 1 1 1
1/17/2019
Data Structure: Heaps

42. Leftist Heap
A leftist heap is a leftist tree with heap order property. 4 5 8 6 21 12 31 15 23 33
1/17/2019
Data Structure: Heaps

43. 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/17/2019
Data Structure: Heaps

44. Merge Leftist Heaps 4 6 5 8 31 15 21 12 33 23
1/17/2019
Data Structure: Heaps

45. Merge Leftist Heaps 8 6 15 8 12 31 15 8 12 23 15 12 23 33 23
1/17/2019
Data Structure: Heaps

46. Merge Leftist Heaps 4 6 31 33 8 12 23 15 5 21
1/17/2019
Data Structure: Heaps

47. 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/17/2019
Data Structure: Heaps

48. 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/17/2019
Data Structure: Heaps

49. 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/17/2019
Data Structure: Heaps

50. Applications Event simulation Merge sort 1/17/2019
Data Structure: Heaps

51. 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/17/2019
Data Structure: Heaps

52. Heap Sort 5 12 23 34 25 30 5 12 23 34 25 30
1/17/2019
Data Structure: Heaps

53. Heap Sort 12 25 23 34 30 5 12 25 23 34 30 5
1/17/2019
Data Structure: Heaps

54. Heap Sort 23 25 30 34 12 5 23 25 30 34 12 5
1/17/2019
Data Structure: Heaps

55. Heap Sort 25 34 30 23 12 5 25 34 30 23 12 5
1/17/2019
Data Structure: Heaps

56. Heap Sort 34 30 25 23 12 5 34 30 25 23 12 5
1/17/2019
Data Structure: Heaps

57. 1/17/2019
Data Structure: Heaps