heaps priority queues. 1/6/2016data structure: heaps2 outline binary heaps binomial queues leftist...
Post on 19-Jan-2016
236 Views
Preview:
TRANSCRIPT
Heaps
Priority Queues
04/21/23 Data Structure: Heaps 2
Outline
Binary heaps
Binomial queues
Leftist heaps
Binary Heaps
04/21/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/21/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/21/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/21/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/21/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/21/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/21/23 Data Structure: Heaps 10
percolateUp
5
12
15 22
16 3 2321
19
25 48
27 36
04/21/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/21/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/21/23 Data Structure: Heaps 13
PercolateDown
32
12
34 25
40 56 4043
23
31 33
30 36 4535
04/21/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/21/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/21/23 Data Structure: Heaps 16
Insertion
5
12
15 22
16 28 2321
19
25 48
27 10
04/21/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/21/23 Data Structure: Heaps 18
DeleteMin
5
12
15 22
16 28 2321
10
19 48
27 25
04/21/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/21/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/21/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/21/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 );
}
Binomial Queues
04/21/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/21/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/21/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/21/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/21/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/21/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/21/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/21/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/21/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/21/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/21/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/21/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/21/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/21/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;
Leftist Heaps
04/21/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/21/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/21/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/21/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/21/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/21/23 Data Structure: Heaps 44
Merge Leftist Heaps
4
5
6
21
15318
12
23
33
04/21/23 Data Structure: Heaps 45
Merge Leftist Heaps
6
15318
12
2333
8
12
23
15
8
12
23
15
04/21/23 Data Structure: Heaps 46
Merge Leftist Heaps
4
5
21
6
31
33
8
12
23
15
04/21/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/21/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/21/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/21/23 Data Structure: Heaps 50
Applications• Event simulation
• Merge sort
04/21/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.
04/21/23 Data Structure: Heaps 52
Heap Sort
5
12
34 25
23
30
5 12 3423 25 30
04/21/23 Data Structure: Heaps 53
Heap Sort
12
25
34 30
23
5
12 25 3423 30 5
04/21/23 Data Structure: Heaps 54
Heap Sort
23
25
34 12
30
5
23 25 3430 12 5
04/21/23 Data Structure: Heaps 55
Heap Sort
25
34
23 12
30
5
25 34 2330 12 5
04/21/23 Data Structure: Heaps 56
Heap Sort
34
30
23 12
25
5
34 30 2325 12 5
04/21/23 Data Structure: Heaps 57
top related