Download - Heaps Priority Queues. 1/6/2016Data Structure: Heaps2 Outline Binary heaps Binomial queues Leftist heaps.

Heaps

Priority Queues

04/21/23 Data Structure: Heaps 2

Outline

Binary heaps

Binomial queues

Leftist heaps

Binary Heaps


Heap order propertyFor every root node N, the key in the parent of N is smaller than or equal to the key in N.

5

12

15 22

16 28 2321

19

25 48

27

The smallest value is in the root.


Operations on priority queues• Insert

– Put an element into the queue

• DeleteMin– Find the minimal element– Return it– Remove it from the queue


Binary Heaps

• A binary heap is an implementation of a priority queue.

• A binary heap is a complete binary tree with heap order property.


Complete Binary TreeA 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

12

34 25

40 56 4043

23

31 33

30 36 4535

Height is in log2 n,

where n is the

number of nodes.


Array implementation of complete binary tree

A

B

D E

I J KH

C

F G

L

A B C D IHGFE J LK 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

12

4

3

5 6 7

8 9 121110


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 heapprivate Comparable [ ] array; // The heap array

}


percolateUp

5

12

15 22

16 3 2321

19

25 48

27 36


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;

}


Method percolateUpprivate 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;

}


PercolateDown

32

12

34 25

40 56 4043

23

31 33

30 36 4535


Method percolateDownprivate 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 childif( array[ child ].compareTo( array[ hole ] ) < 0 )

swap( hole, child );else

break; hole = child;

}}


Method percolateDownprivate void percolateDown( int hole ){ int child;

Comparable tmp = array[ hole ]; // save the value of the nodewhile ( hole * 2 <= currentSize ){ child = hole * 2;

if(child != currentSize&&array[ child+1].compareTo( array[child ])<0)

child++; // choose the smaller childif( 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

}


Insertion

5

12

15 22

16 28 2321

19

25 48

27 10


Method insert

public void insert( Comparable x ) throws Overflow

{ if( isFull( ) ) throw new Overflow( );

array[++currentSize]=x;

percolateUp(currentSize);

}


DeleteMin

5

12

15 22

16 28 2321

10

19 48

27 25


Method deleteMinpublic 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;

}


Method buildHeapprivate void buildHeap( )

{ for( int i = currentSize / 2; i > 0; i-- )

percolateDown( i );

}

32

12

34 25

40 56 4043

23

31 33

30 36 4535


Method decreaseKey

public void decreaseKey(int p, Comparable d) throws outOfRange

{ if( p>currentSize ) throw new outOfRange();array[ p ] = array[ p ] - d;percolateUp( p );

}


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


Binomial TreeA 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.


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

11

3

3

1

1

4

6

4

1

1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 11 6 15 20 15 6 1


Structure• A binomial queue is a collection of heap-

ordered trees, each of which is a binomial tree.

6 3

21

13

16 32

40

26

28 35

43

45

51 46

50


Binomial Nodesclass 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;

}


Examples: binomial nodes

13

16 32

40

26

28 35

43

45

51 46

50

13

16 32

40

26

28 35

43

45

51 46

50

Child

nextSibling


Binomial Queuespublic 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; }

}


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

28 35

43

45

51 46

50

26

28 35

43

45

51 46

50


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 ];


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 carryif (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; }


Method merge (3)// this and carryif (t1!=null && t2==null && carry!=null){ carry = combineTrees( t1, carry );theTrees[ i ] = null; }

// rhs and carryif (t1==null && t2!=null && carry!=null){ carry = combineTrees( t2, carry );rhs.theTrees[ i ] = null; }

// All threeif (t1!=null && t2!=null && carry!=null){ theTrees[ i ] = carry;carry = combineTrees( t1, t2 );rhs.theTrees[ i ] = null; }

}


Method merge (4)

for( int k=0; k < rhs.theTrees.length; k++ )rhs.theTrees[ k ] = null;

rhs.currentSize = 0;}


Method insert

public void insert( Comparable x ) throws Overflow

{ BinomialQueue oneItem= new BinomialQueue( );oneItem.currentSize = 1;oneItem.theTrees[0] = new BinomialNode( x );merge( oneItem );

}


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;

}


Method deleteMinpublic 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


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 0

00

0

0

0


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 0

00

0

0

0


Examples of leftist trees

1

1

1 0

01

0

0

0

1

1

1 0

00

0

0

00

1

1 0

00

1

0

00


Leftist Heap• A leftist heap is a leftist tree with heap order

property.4

5

6 21

1531

8

12

23

33


Leftist Tree Nodesclass 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;

}


Merge Leftist Heaps

4

5

6

21

15318

12

23

33


Merge Leftist Heaps

6

15318

12

2333

8

12

23

15

8

12

23

15


Merge Leftist Heaps

4

5

21

6

31

33

8

12

23

15


Method merge1private static LeftHeapNode merge1

( LeftHeapNode h1, LeftHeapNode h2 ){ if ( h1.left == null ) // Single node

h1.left = h2; // Other fields in h1 OKelse{ h1.right = merge ( h1.right, h2 );

if ( h1.left.npl < h1.right.npl )swapChildren ( h1 );h1.npl = h1.right.npl + 1;

}return h1;

}


Method mergepublic 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 );}


Methods insert, deleteMInpublic 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;

}


Applications• Event simulation

• Merge sort


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.


Heap Sort

5

12

34 25

23

30

5 12 3423 25 30


Heap Sort

12

25

34 30

23

5

12 25 3423 30 5


Heap Sort

23

25

34 12

30

5

23 25 3430 12 5


Heap Sort

25

34

23 12

30

5

25 34 2330 12 5


Heap Sort

34

30

23 12

25

5

34 30 2325 12 5