Heaps Heaps 1

A heap is a complete binary tree.

A max-heap is a complete binary tree in which the value in each internal node is greater
than or equal to the values in the children of that node.
A min-heap is defined similarly.
97

Mapping the elements of 93 84

a heap into an array is
trivial:
90 79 83 81
if a node is stored at
index k, then its left
child is stored at index
42 55 73 21 83
2k+1 and its right child
at index 2k+2

0 1 2 3 4 5 6 7 8 9 10 11
97 93 84 90 79 83 81 42 55 73 21 83

CS@VT Data Structures & Algorithms ©2000-2009 McQuain

Building a Heap Heaps 2

The fact that a heap is a complete binary tree allows it to be efficiently represented
using a simple array.
Given an array of N values, a heap containing those values can be built, in situ, by
simply “sifting” each internal node down to its proper location:

- start with the last 73 73

internal node
- swap the current 74 81
* 74 * 93
internal node with
its larger child, if 79 90 93 79 90 81
necessary
- then follow the
swapped node down
73 * 93

- continue until all

internal nodes are
90 93 90 73
*
done
79 74 81 79 74 81

CS@VT Data Structures & Algorithms ©2000-2009 McQuain

Heap Class Interface Heaps 3
We will consider a somewhat minimal maxheap class:

public class BinaryHeap<T extends Comparable<? super T>> {

private static final int DEFCAP = 10; // default array size

private int size; // # elems in array
private T [] elems; // array of elems

public BinaryHeap() { . . . } // construct heaps in

public BinaryHeap( int capacity ) { . . . } // various ways
public BinaryHeap( T [ ] items ) { . . . }

public boolean insert( T D ) { . . . } // insert new elem

public T findMax() { . . . } // get maximum element
public T deleteMax() { . . . } // remove maximum element
public void clear() { . . . } // reset heap to empty
public boolean isEmpty() { . . . } // is heap empty?

private void siftDown( int hole ) { . . . } // siftdown algorithm

private void buildHeap() { . . . } // heapify
public void printHeap() { . . . } // linear display
}

CS@VT Data Structures & Algorithms ©2000-2009 McQuain

buildHeap and siftDown Heaps 4
As described earlier:
private void buildHeap() {
// first elem is stored at index 1, not 0 QTP: Why is idx
for ( int idx = size / 2; idx > 0; idx-- ) initialized this
siftDown( idx ); way?
}

private void siftDown(int hole) {

int child;
T tmp = elems[ hole ]; Determine which child node
is larger
for ( ; hole * 2 <= size; hole = child ) {

child = hole * 2;
if ( child != size &&
elems[ child + 1 ].compareTo( elems[ child ] ) > 0 )
child++;
if ( elems[ child ].compareTo( tmp ) > 0 ) If child is larger than parent,
elems[ hole ] = elems[ child ]; it must move up
else
break;
}
elems[ hole ] = tmp; Finally, put starting value in
} right place

CS@VT Data Structures & Algorithms ©2000-2009 McQuain

Cost of siftDown Heaps 5
private void siftDown(int hole) {

int child; In the worst case, we

T tmp = elems[ hole ]; perform two element
comparisons…
for ( ; hole * 2 <= size; hole = child ) {

child = hole * 2;
if ( child != size &&
elems[ child + 1 ].compareTo( elems[ child ] ) > 0 )
child++;
if ( elems[ child ].compareTo( tmp ) > 0 )
elems[ hole ] = elems[ child ];
else …and one element copy per
break; iteration
}
elems[ hole ] = tmp;
}

In a complete binary tree of N nodes, the number of levels is at most 1 + log(N).

Since each non-terminating iteration of the loop moves the target value a distance of 1
level, the loop will perform no more than log(N) iterations.
Thus, the worst case cost of SiftDown() is Θ(log N). That’s 2log(N) comparisons
and log(N) swaps.

CS@VT Data Structures & Algorithms ©2000-2009 McQuain

Cost of buildHeap Heaps 6
Suppose we start with a complete binary tree with N nodes; the number of steps required
for sifting values down will be maximized if the tree is also full, in which case N = 2d-1
for some integer d = log N. For example:

level 0: 20 nodes, can sift

42 down d - 1 levels

level 1: 21 nodes, can sift

83 21 down d - 2 levels

level 2: 22 nodes, can sift

90 55 93 81 down d - 3 levels

97 37 73 84 83 95 62 17

We can prove that in general, level k of a full and complete binary tree will contain 2k
nodes, and that those nodes are d – k – 1 levels above the leaves.
Thus…

CS@VT Data Structures & Algorithms ©2000-2009 McQuain

Cost of buildHeap Heaps 7

In the worst case, the number of comparisons BuildHeap() will require in building a heap
of N nodes is given by:

d 1
 d 1 d 1
k 1 
Comparisons  2 2 d  k  1  2 d  1 2  2 k 2 
k k

k 0  k 0 k 0 
 
 2 2 d  d  1  2N  log N  

Since, at worst, there is one move for each two comparisons, the maximum number of
element moves is N – log N + 1.

Hence, building a heap of N nodes is Θ(N) in both comparisons and element moves.

CS@VT Data Structures & Algorithms ©2000-2009 McQuain

Deleting the Root of a Heap Heaps 8
We will see that the most common operation on a heap is the deletion of the root node.
The heap property is maintained by sifting down…

public T deleteMax() {
Check for empty heap
if ( isEmpty( ) )
throw new RuntimeException( );

T maxItem = elems[ 1 ]; Save the root (at index 1),

elems[ 1 ] = elems[ size ]; replace it with the last leaf,
size--;
shrink the heap by one node.
siftDown( 1 );
Sift the new root down to
return maxItem; restore the heap property.
}

QTP: Why is the last leaf chosen as the

replacement for the root?

CS@VT Data Structures & Algorithms ©2000-2009 McQuain

Example of Root Deletion Heaps 9
Given the initial heap:

97

93 84

90 79 83 81 83

42 55 73 21 83 93 84

90 79 83 81

93 42 55 73 21

83 84 In a heap of N nodes, the maximum

distance the root can sift down
would be log N - 1.
90 79 83 81

42 55 73 21

CS@VT Data Structures & Algorithms ©2000-2009 McQuain

Heap Sort Heaps 10
A list can be sorted by first building it into a heap, and then iteratively deleting the root
node from the heap until the heap is empty. If the deleted roots are stored in reverse
order in an array they will be sorted in ascending order (if a max heap is used).

public static void heapSort(Integer[] List, int Sz) {

BinaryHeap<Integer> toSort = new BinaryHeap<Integer>(List, Sz);

int Idx = Sz - 1;
while ( !toSort.isEmpty() ) {
List[Idx] = toSort.deleteMax();
Idx--;
}
}

CS@VT Data Structures & Algorithms ©2000-2009 McQuain

Cost of Deleting the Roots Heaps 11
Recalling the earlier analysis of building a heap, level k of a full and complete binary
tree will contain 2k nodes, and that those nodes are k levels below the root level.
So, when the root is deleted the maximum number of levels the swapped node can sift
down is the number of the level from which that node was swapped.
Thus, in the worst case, for deleting all the roots…

 
d 1 d 1
Comparisons  2 k 2  4 k 2 k 1  4 d  2 2 d 1  1
k

k 1 k 1

 2 N log N   2log N   4 N

As usual, with Heap Sort, this would entail essentially the same number of element
moves.

CS@VT Data Structures & Algorithms ©2000-2009 McQuain

Cost of Heap Sort Heaps 12
Adding in the cost of building the heap from our earlier analysis,

Total Comparisons  2 N  2 log N   2 N log N   2 log N   4 N 

 2 N log N   2 N

and...

Total Swaps  N log N   N

So, in the worst case, Heap Sort is (N log N) in both swaps and comparisons.

CS@VT Data Structures & Algorithms ©2000-2009 McQuain

Priority Queues Heaps 13
A priority queue consists of entries, each of which contains a key field, called the
priority of the entry.

Aside from the usual operations of creation, clearing, tests for full and empty, and
reporting its size, a priority queue has only two operations:

- insertion of a new entry

- removal of the entry having the largest (or smallest) key

Key values need not be unique. If not, then removal may target any entry holding the
largest value.

CS@VT Data Structures & Algorithms ©2000-2009 McQuain

Representation Heaps 14

Representation of a priority queue may be achieved using:

- a sorted list, but…

- an unsorted list, but…
- a max-heap

Priority queues may be used to manage prioritized processes in a time-sharing

environment, time-dependent simulations, and even numerical linear algebra.

CS@VT Data Structures & Algorithms ©2000-2009 McQuain