Chapter 7: Priority Queues  II
7.3 Heaps

An efficient realization of a priority queue uses a
(nonlinear) data structure called a heap −
performs both insertions and removals in logarithmic time O(log n).
7.3.1 The Heap Data
Structure
 A heap is a binary tree storing keys at its internal nodes and
satisfying the following properties:
 HeapOrder:
for every internal node v
other than the root, key(v) ≥ key(parent(v))
 Complete Binary Tree:
let h be the
height of the heap
 for i = 0,
… , h − 2, there
are 2^{i}
nodes of depth i
 at depth h −
1, the internal nodes are to the left of the external
nodes
 The last node
of a heap is the rightmost internal node of depth h − 1
Proposition 7.5: A heap
T storing n keys has height h = [log(n + 1)].
Proof: (we apply the complete binary tree property)
 Let h be the
height of a heap storing n
keys

Since there are 2^{i}
keys at depth i =
0, … , h −2 and at
least one key at depth h
−1, we have n ≥ 1 +
2 + 4 +… + 2^{h −2}
+ 1 = 2^{h −1}, thus, n ≥ 2^{h − 1}, i.e. h ≥
log n + 1.^{
}

Since for complete binary tree when there are 2^{h − 1}
keys at depth h
−1, we have n
≤ 1 + 2 + 4 +… + 2^{h −1} = 2^{h }−1,
thus, n ≤
2^{h} −1,
i.e. h ≤ log (n + 1).
7.3.2 Implementing a Priority
Queue with a Heap
 We can use a heap to implement a priority queue
 We store a (key,
element) item at
each internal node
 We keep track of the position of the last node
The Vector Representation of a
Heap
 We can represent a heap with n keys by means of a vector of length n + 1
 For the node at rank i
 the left child is at rank 2i
 the right child is at rank 2i +1
 Links between nodes are not explicitly stored
 The leaves are not represented
 The cell of at rank 0 is not used
 Operation insertItem
corresponds to inserting at rank n + 1
 Operation removeMin
corresponds to removing at rank 1
 Yields inplace heapsort
Insertion
 Method insertItem
of the priority queue ADT corresponds to the insertion of a
key k to the heap
 The insertion algorithm consists of three steps
 Find the insertion node z (the new last node)
 Store k at z and expand z into an internal node
 Restore the heaporder property (discussed next)
UpHeap Bubbling after an Insertion
 After the insertion of a new key k, the heaporder property may
be violated
 Algorithm upheap restores the heaporder property by
swapping k along an
upward path from the insertion node
 Upheap terminates when the key k reaches the root or a node whose parent
has a key smaller than or equal to k
 Since a heap has height O(log n),
upheap runs in O(log
n) time
Removal
 Method removeMin
of the priority queue ADT corresponds to the removal of the
root key from the heap
 The removal algorithm consists of three steps
 Replace the root key with the key of the last node w
 Compress w
and its children into a leaf
 Restore the heaporder property (discussed next)
DownHeap Bubbling after a
Removal
 After replacing the root key with the key k of the last node, the heaporder property may
be violated
 Algorithm downheap restores the heaporder property by
swapping key k along
a downward path from the root
 Downheap terminates when key k reaches a leaf or a node whose children
have keys greater than or equal to k
 Since a heap has height O(log n),
downheap runs in O(log
n) time
Analysis
Function

Time

size(),
isEmpty()

O(1)

minElement(),
minKey()

O(1)

insertItem(k,e)

O(log n)

removeMin()

O(log n)

7.3.3 C++ Implementation
html7.7
(HeapTree)
html7.8 (HPQ1)
html7.9 (HPQ2)
VisoAlgo
Heap
Visualization
7.3.4 HeapSort
 Consider a priority queue with n items implemented by means of a heap
 the space used is O(n)
 methods insertItem
and removeMin
take O(log n) time
 methods size,
isEmpty, minKey, and minElement take O(1) time
 Using a heapbased priority queue, we can sort a sequence
of n elements in O(n log n) time
 The resulting algorithm is called heapsort
 Heapsort is much faster than quadratic sorting
algorithms, such as insertionsort and selectionsort
Heap
Sort