Heaps

Priority Queues

Outline

Binary heaps Binomial queues

Leftist heaps

9/2/2013

Data Structure: Heaps

Binary Heaps

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 22 28 23 27 25 48

15
21 16

The smallest value is in the root.

9/2/2013 Data Structure: Heaps 4

Operations on priority queues

Insert
Put an element into the queue

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

9/2/2013

Data Structure: Heaps

Binary Heaps
A binary heap is an implementation of a priority queue. A binary heap is a complete binary tree with heap order property.

9/2/2013

Data Structure: Heaps

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 n,
32
2

12 34 43
9/2/2013

23 25 56 40 35 31 30

where n is the number of nodes.

33

40

36

45
7

Data Structure: Heaps

Array implementation of complete binary tree

2

A
5

1 3

B
4 6

C
7

D
8 9 10

E
11 12

A B C D E F G H
1
9/2/2013

I
9 10

J
11

K
12

L
13 14 15
8

3 4

Data Structure: Heaps

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 }
9/2/2013 Data Structure: Heaps 9

percolateUp
5 12 15 21 16 3 22 23 27 25 36 19 48

9/2/2013

Data Structure: Heaps

10

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

9/2/2013

Data Structure: Heaps

11

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; }
9/2/2013 Data Structure: Heaps 12

PercolateDown
32

12
34 43 40

23 25
56 40 35

31
30

33
36 45

9/2/2013

Data Structure: Heaps

13

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; } }
9/2/2013 Data Structure: Heaps 14

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 }
9/2/2013 Data Structure: Heaps 15

Insertion
5 12 15 21 16 22 28 23 27 25 10 19 48

9/2/2013

Data Structure: Heaps

16

Method insert
public void insert( Comparable x ) throws Overflow { if( isFull( ) ) throw new Overflow( ); array[++currentSize]=x; percolateUp(currentSize); }

9/2/2013

Data Structure: Heaps

17

DeleteMin
5 12 15 21 16 22 28 23 27 19 25 10 48

9/2/2013

Data Structure: Heaps

18

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; }
9/2/2013 Data Structure: Heaps 19

Method buildHeap
private void buildHeap( ) { for( int i = currentSize / 2; i > 0; i-- ) percolateDown( i ); }

32 12 34 43
9/2/2013

23 25 56 40 31 33 36 45
20

40

35

30

Data Structure: Heaps

Method decreaseKey
public void decreaseKey(int p, Comparable d) throws outOfRange { if( p>currentSize ) throw new outOfRange(); array[ p ] = array[ p ] - d; percolateUp( p ); }

9/2/2013

Data Structure: Heaps

21

Method increaseKey
public void increaseKey(int p, Comparable d) throws outOfRange { if( p>currentSize ) throw new outOfRange(); array[ p ] = array[ p ] + d; percolateDown( p ); }

9/2/2013

Data Structure: Heaps

22

Binomial Queues

Binomial Tree
A binomial tree is defined recursively as follow: A binomial tree of height 0, denoted by B0, is a onenode 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.

9/2/2013

Data Structure: Heaps

24

Property of Binomial Trees

A binomial tree of height k has 2k nodes.

The number of nodes at depth d is the 1 binomial coefficient k 1 1 d. 1 2 1

1 1
1 1 2 1 4 6 3
9/2/2013

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

1
3

1
Data Structure: Heaps 25

Structure
A binomial queue is a collection of heapordered trees, each of which is a binomial tree.
6 3

13
16 32 40

26 28 35 45 43 51 46 50

21

9/2/2013

Data Structure: Heaps

26

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; }
9/2/2013 Data Structure: Heaps 27

Examples: binomial nodes

13
16 32 40 13 16 32 40

Child nextSibling

26
28 35 45

26 28 35 45 46 50
28

43 51 46
50
9/2/2013 Data Structure: Heaps

43 51

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; } }
9/2/2013 Data Structure: Heaps 29

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
9/2/2013

50

Data Structure: Heaps

50

30

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

9/2/2013

Data Structure: Heaps

31

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; }
9/2/2013 Data Structure: Heaps 32

Method merge (3)

// this and carry if (t1!=null && t2==null && { carry = combineTrees( t1, theTrees[ i ] = null; // rhs and carry if (t1==null && t2!=null && { carry = combineTrees( t2, rhs.theTrees[ i ] = null; // All three if (t1!=null && t2!=null && { theTrees[ i ] = carry; carry = combineTrees( t1, rhs.theTrees[ i ] = null; }
9/2/2013

carry!=null) carry ); } carry!=null) carry ); } carry!=null) t2 ); }

33

Data Structure: Heaps

Method merge (4)

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

9/2/2013

Data Structure: Heaps

34

Method insert
public void insert( Comparable x ) throws Overflow { BinomialQueue oneItem= new BinomialQueue( ); oneItem.currentSize = 1; oneItem.theTrees[0] = new BinomialNode( x ); merge( oneItem ); }

9/2/2013

Data Structure: Heaps

35

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; }
9/2/2013 Data Structure: Heaps 36

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;

9/2/2013

Data Structure: Heaps

37

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 0 0 0 0 0

9/2/2013

Data Structure: Heaps

39

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

0
0 0 0
40

1
0
9/2/2013

Data Structure: Heaps

Examples of leftist trees

1 1 1 1 0 0
9/2/2013 Data Structure: Heaps

1
0

1
1 0 0

0
1

0 0 0

0 0 0 0
1 0 1 0 0

41

Leftist Heap
A leftist heap is a leftist tree with heap order property.
4
5 6 31 15 33
9/2/2013 Data Structure: Heaps 42

8 21 23 12

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; LeftHeapNode left; }
9/2/2013 Data Structure: Heaps

int npl; LeftHeapNode right;

43

Merge Leftist Heaps

4 5 21 23 12 6

31

15 33

9/2/2013

Data Structure: Heaps

44

Merge Leftist Heaps

6 8 31 15 8 12 23 8 15

12 33 12 15 23 23

9/2/2013

Data Structure: Heaps

45

Merge Leftist Heaps

4 5 21 6

31
33 12 23

8 15

9/2/2013

Data Structure: Heaps

46

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; }
9/2/2013 Data Structure: Heaps 47

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 ); }
9/2/2013 Data Structure: Heaps 48

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; }
9/2/2013 Data Structure: Heaps 49

Applications
Event simulation Merge sort

9/2/2013

Data Structure: Heaps

50

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.

9/2/2013

Data Structure: Heaps

51

Heap Sort
5 12 34 25 30 23

5 12 23 34 25 30
9/2/2013 Data Structure: Heaps 52

Heap Sort
12 25 34 30 5 23

12 25 23 34 30 5
9/2/2013 Data Structure: Heaps 53

Heap Sort
23 25 34 12 5 30

23 25 30 34 12 5
9/2/2013 Data Structure: Heaps 54

Heap Sort
25 34 23 12 5 30

25 34 30 23 12 5
9/2/2013 Data Structure: Heaps 55

Heap Sort
34 30 23 12 5 25

34 30 25 23 12 5
9/2/2013 Data Structure: Heaps 56

9/2/2013

Data Structure: Heaps

57