CMSC 341

Binary Heaps

Priority Queues

2

Priority Queues

Priority: some property of an object that allows it to be prioritized WRT other objects (of the same type)

Priority Queue: homogeneous collection of Comparables with the following operations (duplicates are allowed)– void insert (const Comparable &x)– void deleteMin()– void deleteMin ( Comparable & min)– const Comparable &findMin() const – Construct from set of initial values– bool isEmpty() const– bool isFull() const– void makeEmpty()

3

Priority Queue Applications

Printer management: the shorter document on the printer queue, the higher its priority.

Jobs queue: users’ tasks are given priorities. System priority high.

Simulations

Sorting

4

Possible Implementations

Use sorted list. Sort by priority upon insertion.

– findMin() --> Itr.retrieve()

– insert() --> list.insert()

– deleteMin() --> list.delete(1)

Use ordinary BST

– findMin() --> tree.findMin()

– insert() --> tree.insert()

– deleteMin() --> tree.delete(tree.findMin())

Use balanced BST

– guaranteed O(lg n) for AVL, Red-Black

5

Binary Heap

A binary heap is a CBT with the further property that at every vertex neither child is smaller than the vertex, called partial ordering.

Every path from the root to a leaf visits vertices in a non-decreasing order.

6

Binary Heap Properties

For a node at index i

– its left child is at index 2i

– its right child is at index 2i+1

– its parent is at index i/2No pointer storage

Fast computation of 2i and i/2i << 1 = 2i

i >> 1 = i/2

7

Binary Heap Performance

Performance– construction O(n)

– findMin O(1)

– insert O(lg n)

– deleteMin O(lg n)

Heap efficiency results, in part, from the implementation

– conceptually a binary tree

– implementation in an array (in level order), root at index 1

8

BinaryHeap.Htemplate <class Comparable>class Binary Heap {public:

explicit BinaryHeap(int capacity = BIG);bool isEmpty() const;bool isFull() const;const Comparable & findMin() const;void insert (const Comparable & x);void deleteMin();void deleteMin(Comparable & min_item);void makeEmpty();

private:int currentSize;vector<Comparable> array;void buildHeap();void percolateDown(int hole);

};

9

BinaryHeap.Ctemplate <class Comparable>

const Comparable & BinaryHeap::findMin( ) {

if ( isEmpty( ) ) throw Underflow( );

return array[1];

}

10

Insert Operation

Must maintain

– CBT property (heap shape): • easy, just insert new element at the right of the array

– Heap order• could be wrong after insertion if new element is smaller than

its ancestors

• continuously swap the new element with its parent until parent is not greater than it

– called sift up or percolate up

Performance O(lg n) worst case because height of CBT is O(lg n)

11

BinaryHeap.C (cont)template <class Comparable>void BinaryHeap<Comparable>::insert(const Comparable & x){

if (isFull()) throw OverFlow();int hole = ++currentSize;

// percolate upfor (; hole > 1 && x < array[hole/2]; hole /= 2)

array[hole] = array[hole/2];

// put x in holearray[hole] = x;

}

12

Deletion Operation

Steps

– remove min element (the root)

– maintain heap shape

– maintain heap order

To maintain heap shape, actual vertex removed is last one

– replace root value with value from last vertex and delete last vertex

– sift-down the new root value • continually exchange value with the smaller child until no

child is smaller

13

BinaryHeap.C (cont)template <class Comparable>

void BinaryHeap<Comparable>::

deleteMin(Comparable & minItem)

{

if ( isEmpty( ) ) throw Underflow( );

minItem = array[1];

array[1] = array[currentSize--];

percolateDown(1);

}

14

BinaryHeap.C (cont)template <class Comparable>void BinaryHeap<Comparable>::percolateDown(int hole){

int child;Comparable tmp = array[hole];for (; hole * 2 <= currentSize; hole = child){

child= hole * 2;if (child != currentSize&& array[child + 1] < array[ child ] )

child++;if (array [child] < tmp)

array[ hole ] = array[ child ];else break;

}array[hole] = tmp;

}

15

Constructing a Binary Heap

A BH can be constructed in O(n) time.

Suppose an array in arbitrary order. It can be put in heap order in O(n) time.

– Create the array and store n elements in it in arbitrary order. O(n)

– Heapify the array• start at vertex i = n/2

– percolateDown(i)

• repeat for all vertices down to i

16

BinaryHeap.C (cont)

template <class Comparable>

void BinaryHeap<Comparable>::

buildHeap( )

{

for(int i = currentSize/2; i >0; i--)

percolateDown(i);

}

17

Performance of ConstructionA CBT has 2h-1 vertices on level h-1.

On level h-l, at most 1 swap is needed per node.

On level h-2, at most 2 swaps are needed.

…

On level 0, at most h swaps are needed.

Number of swaps = S

= 2h*0 + 2h-1*1 + 2h-2*2 + … + 20*h

=

= h(2h+1-1) - ((h-1)2h+1+2)

= 2h+1(h-(h-1))-h-2

= 2h+1-h-2

h

i

ih

i

ih

i

i ihih000

22)(2

18

Performance of Construction (cont)

But 2h+1-h-2 = O(2h)

But n = 1 + 2 + 4 + … + 2h =

Therefore, n = O(2h)

So S = O(n)

A heap of n vertices can be built in O(n) time.

h

i

i

0

2

19

Heap Sort

Given n values, can sort in O(n log n) time (in place).– Insert values into array -- O(n)– heapify -- O(n)– repeatedly delete min -- O(lg n) n times

Using a min heap, this code sorts in reverse order. With a max heap, it sorts in normal order.

for (i = n-1; i >= 1; i--){

x =findMin();deleteMin();A[i+1] = x;

}

20

Limitations

Binary heaps support insert, findMin, deleteMin, and construct efficiently.

They do not efficiently support the meld or merge operation in which 2 PQs are merged into one. If P1 and P2 are of size n1 and n2, then the merge is in O(n1 + n2)

21

Leftist Heap

Supports

– findMin -- O(1)

– deleteMin -- O(lg n)

– insert -- O(lg n)

– construct -- O(n)

– merge -- O(lg n)

22

Leftist Tree

A LT is a binary tree in which at each vertex v, the path length, dr, from v’s right child to the nearest non-full vertex is not larger than that from the vertex’s left child to the nearest non-full vertex.

An important property of leftist trees:

– At every vertex, the shortest path to a non-full vertex is along the rightmost path.

– Suppose this was not true. Then, at the same vertex the path on the left would be shorter than the path on the right.

23

Leftist Heap

A leftist heap is a leftist tree in which the values in the vertices obey heap order (the tree is partially ordered).

Since a LH is not necessarily a CBT we do not implement it in an array. An explicit tree implementation is used.

Operations

– findMin -- return root value, same as BH

– deleteMin -- done using meld operation

– insert -- done using meld operation

– construct -- done using meld operation

24

Meld

Algorithm:

Meld (H1, H2) {

if (!root(H1) || (root_value(H1) > root_value(H2) )

swap (H1, H2)

if (root(H1) != NULL))

right(H1) <-- Meld(right(H1),H2)

if (left_length(H1) < right_length(H1)

swap(left(H1), right(H1);

}

25

Meld (cont)

Performance: O(lg n)

– the rightmost path of each tree has at most lg(n+1) vertices. So O(lg n) vertices will be involved.

26

27

28

29

Leftist Heap Operations

Other operations implemented in terms of Meld

– insert (item)• make item into a 1-vertex LH, X

• Meld(*this, X)

– deleteMin• Meld(left subtree, right subtree)

– construct from N items• make N LH from the N values, one element in each

• meld each in

– one at a time :

– use queue and build pairwise :

30

LH Construct

Algorithm:

– make N heaps each with one data value

– Queue Q;

– for (I=1; I <= N; I++) Q.Enqueue(Hi);

– Heap H = Q.Dequeue();

– while (!Q.IsEmpty())Q.Enqueue(meld(H,Q.Dequeue());

H = Q.Dequeue();