Heaps

1
Heaps

• Priority Queues

2
Outline

• Binary heaps
• Binomial queues
• Leftist 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
The smallest value is in the root.
5
Operations on priority queues

• Insert
• Put an element into the queue
• DeleteMin
• Find the minimal element
• Return it
• Remove it from the queue

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.

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.
8
Array implementation of complete binary tree
A
1
2
3
4
5
6
7
12
11
8
9
10
A
B
C
D
I
H
G
F
E
J


L
K

1 2 3 4 5 6 7 8 9 10 11 12
13 14 15
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

10
percolateUp
5
12
19
22
25
36
3
11
Method percolateUp

• private void percolateUp( int hole )
• Comparable x arrayhole
• while (hole gt 1 x.compareTo( array hole / 2
  ) lt 0)
• array hole array hole/2
• hole hole/2
• array hole x

12
Method percolateUp

• private void percolateUp( int hole )
• while (holegt1 arrayhole.compareTo( array
  hole/2 )lt0)
• swap(hole, hole/2)
• hole hole/2
• private void swap( int p1, int p2 )
• Comparable x arrayp1
• arrayp1 arrayp2
• arrayp2 x

13
PercolateDown
32
12
23
34
25
31
33
36
45
30
35
40
40
56
43
14
Method percolateDown

• private void percolateDown( int hole )
• int child
• while( hole 2 lt currentSize)
• child hole 2
• if(child ! currentSizearray
  child1.compareTo( arraychild )lt0)
• child // choose the smaller child
• if( array child .compareTo( array hole ) lt
  0 )
• swap( hole, child )
• else
• break
• hole child

15
Method percolateDown

• private void percolateDown( int hole )
• int child
• Comparable tmp array hole //
  save the value of the node
• while ( hole 2 lt currentSize )
• child hole 2
• if(child ! currentSizearray
  child1.compareTo( arraychild )lt0)
• child // choose the smaller child
• if( array child .compareTo( tmp ) lt 0 )
• array hole array child // move child
  up
• hole child // move hole down
• else
• break
• array hole tmp // put the value in the
  hole

16
Insertion
5
19
25
10
17
Method insert

• public void insert( Comparable x ) throws
  Overflow
• if( isFull( ) ) throw new Overflow( )
• arraycurrentSizex
• percolateUp(currentSize)

18
DeleteMin
5
12
10
19
48
25
19
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

20
Method buildHeap

• private void buildHeap( )
• for( int i currentSize / 2 i gt 0 i-- )
• percolateDown( i )

32
12
23
34
25
31
33
36
45
30
35
40
40
56
43
21
Method decreaseKey

• public void decreaseKey(int p, Comparable d)
• throws outOfRange
• if( pgtcurrentSize ) throw new outOfRange()
• array p array p - d
• percolateUp( p )

22
Method increaseKey

• public void increaseKey(int p, Comparable d)
• throws outOfRange
• if( pgtcurrentSize ) throw new outOfRange()
• array p array p d
• percolateDown( p )

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.

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 3 3 1 1 4 6 4
1 1 5 10 10 5 1 1 6 15 20 15 6 1
26
Structure

• A binomial queue is a collection of heap-ordered
  trees, each of which is a binomial tree.

6
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

28
Examples binomial nodes
13
Child
32
16
nextSibling
40
26
28
35
45
43
51
46
50
29
Binomial Queues

• public class BinomialQueue
• public BinomialQueue( )
• theTrees new BinomialNode MAX_TREES
• makeEmpty( )
• ...
• public void makeEmpty( )
• currentSize 0
• for( int i0 i lt theTrees.length i )
• theTrees i null
• private static final int MAX_TREES 14
• private int currentSize
• private BinomialNode theTrees
• private int capacity( )
• return 2theTrees.length - 1

30
Method combineTrees

• private static BinomialNode combineTrees
• ( BinomialNode t1,BinomialNode t2 )
• if( t1.element.compareTo( t2.element ) gt 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
31
Method merge (1)

• public void merge( BinomialQueue rhs )
• throws Overflow
• if( this rhs ) return
• if( currentSizerhs.currentSizegtcapacity() )
• throw new Overflow( )
• currentSize rhs.currentSize
• BinomialNode carry null
• for( int i0,j1 jltcurrentSize i,j2 )
• BinomialNode t1 theTrees i
• BinomialNode t2 rhs.theTrees i

32
Method merge (2)

• // No trees
• if (t1null t2null carrynull)
• // Only this
• if (t1!null t2null carrynull)
• // Only rhs
• if (t1null t2!null carrynull)
• theTreesi t2 rhs.theTreesi null
• // Only carry
• if (t1null t2null carry!null)
• theTrees i carry carry null
• // this rhs
• if (t1!null t2null carry!null)
• carry combineTrees( t1, t2 )
• theTreesirhs.theTreesinull

33
Method merge (3)

• // this and carry
• if (t1!null t2null carry!null)
• carry combineTrees( t1, carry )
• theTrees i null
• // rhs and carry
• if (t1null 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 )
• rhs.theTrees i null

34
Method merge (4)

• for( int k0 k lt rhs.theTrees.length k )
• rhs.theTrees k null
• rhs.currentSize 0

35
Method insert

• public void insert( Comparable x )
• throws Overflow
• BinomialQueue oneItem new BinomialQueue( )
• oneItem.currentSize 1
• oneItem.theTrees0 new BinomialNode( x )
• merge( oneItem )

36
Method deleteMin (2)

• for( int j minIndex - 1 j gt 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

37
Method deleteMin

• public Comparable deleteMin( )
• if( isEmpty( ) ) return null
• int minIndex findMinIndex( )
• Comparable minItem
• theTreesminIndex.element
• BinomialNode deletedTree
• theTrees minIndex .child
• BinomialQueue deletedQueue
• new BinomialQueue( )
• deletedQueue.currentSize (1 ltlt minIndex)-1

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
0
1
0
0
0
0
0
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
0
1
0
0
0
0
0
41
Examples of leftist trees
1
1
1
0
1
0
1
1
0
0
1
0
0
0
0
0
1
0
0
0
0
1
0
0
1
0
0
0
42
Leftist Heap

• A leftist heap is a leftist tree with heap order
  property.

4
5
8
6
21
12
15
31
23
33
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

44
Merge Leftist Heaps
4
6
5
8
15
31
21
12
33
23
45
Merge Leftist Heaps
8
6
15
8
12
15
31
12
23
33
23
46
Merge Leftist Heaps
4
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 lt h1.right.npl )
• swapChildren( h1 )
• h1.npl h1.right.npl 1
• return h1

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 ) lt 0 )
• return merge1( h1, h2 )
• else
• return merge1( h2, h1 )

49
Methods insert, deleteMIn

• public void insert( Comparable x )
• rootmerge(new LeftHeapNode(x),root)
• public Comparable deleteMin( )
• if( isEmpty( ) ) return null
• Comparable minItem root.element
• root merge( root.left, root.right )
• return minItem

50
Applications

• Event simulation
• Merge sort

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.

52
Heap Sort
5
12
23
34
25
30
5
12
34
23
25
30
53
Heap Sort
12
23
34
30
5
12
25
34
23
30
5
54
Heap Sort
23
25
30
34
12
5
23
25
34
30
12
5
55
Heap Sort
25
34
30
23
12
5
25
34
23
30
12
5
56
Heap Sort
34
30
25
23
12
5
34
30
23
25
12
5
57
(No Transcript)