Upload
wilma-allen
View
45
Download
0
Tags:
Embed Size (px)
DESCRIPTION
Heaps. Priority Queues. Outline. Binary heaps Binomial queues Leftist heaps. Binary Heaps. 12. 19. 22. 25. 48. 15. 27. 23. 21. 16. 28. 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. - PowerPoint PPT Presentation
Citation preview
04/20/23 Data Structure: Heaps 4
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.
04/20/23 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
04/20/23 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.
04/20/23 Data Structure: Heaps 7
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.
04/20/23 Data Structure: Heaps 8
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
04/20/23 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 heapprivate Comparable [ ] array; // The heap array
}
04/20/23 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;
}
04/20/23 Data Structure: Heaps 12
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;
}
04/20/23 Data Structure: Heaps 14
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;
}}
04/20/23 Data Structure: Heaps 15
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
}
04/20/23 Data Structure: Heaps 17
Method insert
public void insert( Comparable x ) throws Overflow
{ if( isFull( ) ) throw new Overflow( );
array[++currentSize]=x;
percolateUp(currentSize);
}
04/20/23 Data Structure: Heaps 19
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;
}
04/20/23 Data Structure: Heaps 20
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
04/20/23 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 );
}
04/20/23 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 );
}
04/20/23 Data Structure: Heaps 24
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.
04/20/23 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
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
04/20/23 Data Structure: Heaps 26
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
04/20/23 Data Structure: Heaps 27
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;
}
04/20/23 Data Structure: Heaps 28
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
04/20/23 Data Structure: Heaps 29
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; }
}
04/20/23 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
28 35
43
45
51 46
50
26
28 35
43
45
51 46
50
04/20/23 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 ];
04/20/23 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 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; }
04/20/23 Data Structure: Heaps 33
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; }
}
04/20/23 Data Structure: Heaps 34
Method merge (4)
for( int k=0; k < rhs.theTrees.length; k++ )rhs.theTrees[ k ] = null;
rhs.currentSize = 0;}
04/20/23 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 );
}
04/20/23 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;
}
04/20/23 Data Structure: Heaps 37
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;
04/20/23 Data Structure: 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 0
00
0
0
0
04/20/23 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 0
00
0
0
0
04/20/23 Data Structure: Heaps 41
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
04/20/23 Data Structure: Heaps 42
Leftist Heap• A leftist heap is a leftist tree with heap order
property.4
5
6 21
1531
8
12
23
33
04/20/23 Data Structure: Heaps 43
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;
}
04/20/23 Data Structure: Heaps 47
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;
}
04/20/23 Data Structure: Heaps 48
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 );}
04/20/23 Data Structure: Heaps 49
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;
}
04/20/23 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.