Sell 100 IBM $122

Sell 300 IBM $120

Buy 500 IBM $119
Buy 400 IBM $118

Priority Queues
Data structures and Algorithms

Acknowledgement:
These slides are adapted from slides provided with Data Structures and Algorithms in C++
Goodrich, Tamassia and Mount (Wiley, 2004)
Outline
Priority Queues (§8.1)
Sorting with Priority Queues (§8.2)
Heaps (§8.3)
Adaptable Priority Queues (§8.4)

Priority Queues 2
Priority Queue ADT
A priority queue stores a Additional methods
collection of entries
min()
Each entry is a pair returns, but does not
remove, an entry with
(key, value) smallest key
Main methods of the
size(), isEmpty()
Priority Queue ADT

insert(k, x)
inserts an entry with key k
and value x Applications:

removeMin()
Standby flyers
removes and returns the
Auctions
entry with smallest key
Stock market

Priority Queues 3
Total Order Relations
Keys in a priority Mathematical concept
queue can be of total order relation ≤
arbitrary objects on
Reflexive property:
x≤x
which an order is

Antisymmetric property:
defined x≤y∧y≤x⇒x=y
Two distinct entries
Transitive property:
in a priority queue x≤y∧y≤z⇒x≤z
can have the same
key

Priority Queues 4
Entry ADT
An entry in a priority As a Java interface:
queue is simply a key- /**
value pair * Interface for a key-value
Priority queues store * pair entry
entries to allow for **/
efficient insertion and public interface Entry {
removal based on keys public Object key();
Methods: public Object value();

key(): returns the key }
for this entry

value(): returns the
value associated with
this entry
Phạm Bảo Sơn - DSA
Priority Queues 5
Comparator ADT (§8.1.2)
A comparator encapsulates the action of comparing two objects
according to a given total order relation
The primary method of the Comparator ADT:

compare(x, y): Returns an integer i such that i < 0 if a < b, i = 0 if a = b,
and i > 0 if a > b; an error occurs if a and b cannot be compared.

A generic priority queue uses a comparator as a template argument, to

define the comparison function (<,=,>)

When the priority queue needs to compare two keys, it uses its comparator
The comparator is external to the keys being compared. Thus, the
same objects can be sorted in different ways by using different
comparators.

Different priority queues with different total order relations

Priority Queues 6
Using Comparators in C++
• A comparator class overloads • To use the comparator,
the “()” operator with a define an object of this type,
comparison function. and invoke it using its “()”
• Example: Compare two points operator:
in the plane lexicographically. • Example of usage:
class LexCompare { Point p(2.3, 4.5);
public: Point q(1.7, 7.3);
int operator()(Point a, Point b) { LexCompare lexCompare;
if (a.x < b.x) return –1
else if (a.x > b.x) return +1 if (lexCompare(p, q) < 0)
else if (a.y < b.y) return –1 cout << “p less than q”;
else if (a.y > b.y) return +1 else if (lexCompare(p, q) == 0)
else return 0; cout << “p equals q”;
} else if (lexCompare(p, q) > 0)
}; cout << “p greater than q”;

Priority Queues 7
PQ-Sort:
Sorting with a Priority Queue
We can use a priority
queue to sort a set of Algorithm PQ-Sort(S, C)
Input sequence S, comparator C
comparable elements
for the elements of S
1. Insert the elements
Output sequence S sorted in
one by one with a series
of insert operations increasing order according to C
2. Remove the elements in P ← priority queue with
sorted order with a series comparator C
of removeMin operations while ¬S.isEmpty ()
e ← S.removeFirst ()
Running time depends on P.insert (e, 0)
the priority queue while ¬P.isEmpty()
implementation e ← P.removeMin().key()
S.insertLast(e)

Priority Queues 8
Sequence-based Priority Queue
Unsorted list Sorted list
implementation implementation
4 5 2 3 1 1 2 3 4 5

Performance: Performance:

insert takes O(1) time since
insert takes O(n) time since
we can insert the item at we have to find the place
the beginning or end of the where to insert the item
sequence

removeMin and min take
removeMin and min take
O(n) time since we have to O(1) time, since the
traverse the entire smallest key is at the
sequence to find the beginning
smallest key

Priority Queues 9
Selection-Sort
Selection-sort is the variation of PQ-sort where the
priority queue is implemented with an unsorted
sequence 4 5 2 3 1

Running time of Selection-sort:

1. Inserting the elements into the priority queue with n insert
operations takes O(n) time
2. Removing the elements in sorted order from the priority
queue with n removeMin operations takes time
proportional to
1 + 2 + …+ n
Selection-sort runs in O(n2) time

Priority Queues 10
Selection-Sort Example
Sequence S Priority Queue P
Input: (7,4,8,2,5,3,9) ()

Phase 1
(a) (4,8,2,5,3,9) (7)
(b) (8,2,5,3,9) (7,4)
.. .. ..
. . .
(g) () (7,4,8,2,5,3,9)
Phase 2
(a) (2) (7,4,8,5,3,9)
(b) (2,3) (7,4,8,5,9)
(c) (2,3,4) (7,8,5,9)
(d) (2,3,4,5) (7,8,9)
(e) (2,3,4,5,7) (8,9)
(f) (2,3,4,5,7,8) (9)
(g) (2,3,4,5,7,8,9) ()
Phạm Bảo Sơn - DSA
Priority Queues 11
Insertion-Sort
Insertion-sort is the variation of PQ-sort where the
priority queue is implemented with a sorted sequence
1 2 3 4 5

Running time of Insertion-sort:

1. Inserting the elements into the priority queue with n insert
operations takes time proportional to
1 + 2 + …+ n
2. Removing the elements in sorted order from the priority queue
with a series of n removeMin operations takes O(n) time
Insertion-sort runs in O(n2) time

Priority Queues 12
Insertion-Sort Example
Sequence S Priority queue P
Input: (7,4,8,2,5,3,9) ()

Phase 1
(a) (4,8,2,5,3,9) (7)
(b) (8,2,5,3,9) (4,7)
(c) (2,5,3,9) (4,7,8)
(d) (5,3,9) (2,4,7,8)
(e) (3,9) (2,4,5,7,8)
(f) (9) (2,3,4,5,7,8)
(g) () (2,3,4,5,7,8,9)

Phase 2
(a) (2) (3,4,5,7,8,9)
(b) (2,3) (4,5,7,8,9)
.. .. ..
. . .
(g) (2,3,4,5,7,8,9) ()
Phạm Bảo Sơn - DSA
Priority Queues 13
In-place Insertion-sort
Instead of using an 5 4 2 3 1
external data structure,
we can implement 5 4 2 3 1
selection-sort and
insertion-sort in-place 4 5 2 3 1
A portion of the input
sequence itself serves as
2 4 5 3 1
the priority queue
For in-place insertion-sort
2 3 4 5 1

We keep sorted the initial
portion of the sequence

We can use swaps 1 2 3 4 5
instead of modifying the
sequence 1 2 3 4 5
Phạm Bảo Sơn - DSA
Priority Queues 14
Heaps and Priority Queues

5 6

9 7

Priority Queues 15
Recall Priority Queue ADT
A priority queue stores a collection of
entries
Each entry is a pair (key, value)
Main methods

insert(k, x) inserts an entry with key k and value
x

removeMin() removes and returns the entry
with smallest key
Additional methods

min() returns, but does not remove, an entry
with smallest keyPriority Queues 16

size(), isEmpty()
Recall Priority Queue
Sorting
We can use a priority
queue to sort a set of
comparable elements Algorithm PQ-Sort(S, C)

Insert the elements with a Input sequence S, comparator C
series of insert operations for the elements of S

Remove the elements in Output sequence S sorted in
sorted order with a series increasing order according to C
of removeMin operations
The running time depends P ← priority queue with
on the priority queue comparator C
implementation: while ¬S.isEmpty ()

Unsorted sequence gives
selection-sort: O(n2) time e ← S.remove (S. first ())

Sorted sequence gives P.insertItem(e, e)
insertion-sort: O(n2) time while ¬P.isEmpty()
Can we do better? e ← P.removeMin()
Phạm Bảo Sơn - DSA
S.insertLast(e)
Priority Queues 17
What is a heap
A heap is a binary tree The last node of a heap
storing keys at its nodes is the rightmost node of
and satisfying the following depth h
properties:

Heap-Order: for every
2
internal node v other than
the root,
key(v) ≥ key(parent(v)) 5 6

Complete Binary Tree: let h
be the height of the heap 9 7
 for i = 0, … , h − 1, there are
2i nodes of depth i
 at depth h − 1, the internal
nodes are to the left of the
external nodes
last node
Phạm Bảo Sơn - DSA
Priority Queues 18
Height of a Heap
Theorem: A heap storing n keys has height O(log n)
Proof: (we apply the complete binary tree property)

Let h be the height of a heap storing n keys

Since there are 2i keys at depth i = 0, … , h − 1 and at least one key
at depth h, we have n ≥ 1 + 2 + 4 + … + 2h−1 + 1

Thus, n ≥ 2h , i.e., h ≤ log n

depth keys
0 1

1 2

h−1 2h−1

h 1

Phạm Bảo Sơn - DSA

Priority Queues 19
Heaps and Priority Queues
We can use a heap to implement a priority queue
We store a (key, value) entry at each node
We keep track of the position of the last node
For simplicity, we show only the keys in the pictures
(2, Sue)

(5, Pat) (6, Mark)

(9, Jeff) (7, Anna)

Priority Queues 20
Insertion into a Heap
Method insert of the 2
priority queue ADT
corresponds to the 5 6
z
insertion of a key k to the 9 7
heap
The insertion algorithm insertion node
consists of three steps 2
1. Find the insertion node z
5 6
(the new last node)
2. Store k at z 9 7
z 1
3. Restore the heap-order
property (discussed next)

Priority Queues 21
Upheap
• After the insertion of a new key k, the heap-order property
may be violated
• Algorithm upheap restores the heap-order 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
2 1

5 1 5 2

9 7
z 6 9 7
z 6

Priority Queues 22
Removal from a Heap
2
Method removeMin of the
priority queue ADT 5 6

corresponds to the removal of w

9 7
the root key from the heap
The removal algorithm last node
consists of three steps: 7
1. Replace the root key with the
key of the last node w 5 6
w
2. Remove w 9
3. Restore the heap-order
property (discussed next) new last node

Priority Queues 23
Downheap
After replacing the root key with the key k of the last node, the
heap-order property may be violated
Algorithm downheap restores the heap-order 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

7 5

5 6 7 6
w w
9 9

Phạm Bảo Sơn - DSA

Priority Queues 24
Updating the Last Node
The insertion node can be found by traversing a path of O(log n)
nodes

Go up until a left child or the root is reached

If a left child is reached, go to the right child

Go down left until a leaf is reached
Similar algorithm for updating the last node after a removal

Priority Queues 25
Heap-Sort
Consider a priority queue with n items
implemented by means of a heap

the space used is O(n)

methods insert and removeMin take O(log n) time

methods size, isEmpty, and min take O(1) time
Using a heap-based priority queue, we can sort
a sequence of n elements in O(n log n) time
The resulting algorithm is called heap-sort
Heap-sort is much faster than quadratic sorting
algorithms, such as insertion-sort and selection-
sort
Priority Queues 26
Vector-based Heap
Implementation
We can represent a heap with n keys 2
by means of a vector of length n + 1
5 6
For the node at rank i

the left child is at rank 2i 9 7

the right child is at rank 2i + 1
Links between nodes are not explicitly stored
The cell of at rank 0 is not used
Operation insert corresponds to 2 5 6 9 7
inserting at rank n + 1 0 1 2 3 4 5
Operation removeMin corresponds to
removing at rank n
Result: in-place heap-sort

Priority Queues 27
Merging Two Heaps
3 2
We are given two two
8 5 4 6
heaps and a key k
We create a new heap
with the root node 7
storing k and with the 3 2
two heaps as subtrees 8 5 4 6
We perform downheap
to restore the heap-
2
order property
3 4
8 5 7 6

Phạm Bảo Sơn - DSA

Priority Queues 28
Bottom-up Heap
Construction
We can construct a
heap storing n given
keys in using a bottom- 2i −1 2i −1

up construction with
log n phases
In phase i, pairs of
heaps with 2i −1 keys
are merged into heaps 2i+1−1
with 2i+1−1 keys
Phạm Bảo Sơn - DSA
Priority Queues 29
Example

16 15 4 12 6 7 23 20

25 5 11 27

16 15 4 12 6 7 23 20

Phạm Bảo Sơn - DSA

Priority Queues 30
Example (contd.)

25 5 11 27

16 15 4 12 6 9 23 20

15 4 6 23

16 25 5 12 11 9 27 20

Phạm Bảo Sơn - DSA

Priority Queues 31
Example (contd.)
7 8

15 4 6 23

16 25 5 12 11 9 27 20

4 6

15 5 8 23

16 25 7 12 11 9 27 20

Phạm Bảo Sơn - DSA

Priority Queues 32
Example (end)
10

4 6

15 5 8 23

16 25 7 12 11 9 27 20

5 6

15 7 8 23

16 25 10 12 11 9 27 20

Phạm Bảo Sơn - DSA

Priority Queues 33
Analysis
We visualize the worst-case time of a downheap with a proxy path
that goes first right and then repeatedly goes left until the bottom
of the heap (this path may differ from the actual downheap path)
Since each node is traversed by at most two proxy paths, the total
number of nodes of the proxy paths is O(n)
Thus, bottom-up heap construction runs in O(n) time
Bottom-up heap construction is faster than n successive insertions
and speeds up the first phase of heap-sort

Priority Queues 34
 3 a

Adaptable
Priority Queues

5 g 4 e

Priority Queues 35
Recall the Entry and Priority
Queue ADTs
An entry stores a (key, Priority Queue ADT:
value) pair within a data
insert(k, x)
structure inserts an entry with
key k and value x
Methods of Entry ADT:
removeMin()

key(): returns the key removes and returns
associated with this entry the entry with
smallest key

value(): returns the value

min()
paired with the key
returns, but does not
associated with this entry remove, an entry
with smallest key

size(), isEmpty()
Priority Queues 36
Motivating Example
Suppose we have an online trading system where orders
to purchase and sell a given stock are stored in two
priority queues (one for sell orders and one for buy
orders) as (p,s) entries:

The key, p, of an order is the price

The value, s, for an entry is the number of shares

A buy order (p,s) is executed when a sell order (p’,s’) with price
p’<p is added (the execution is complete if s’>s)

A sell order (p,s) is executed when a buy order (p’,s’) with price
p’>p is added (the execution is complete if s’>s)
What if someone wishes to cancel their order before it
executes?
What if someone wishes to update the price or number of
shares for their order?
Priority Queues 37
Methods of the Adaptable
Priority Queue ADT
remove(e): Remove from P and return
entry e.
replaceKey(e,k): Replace with k and
return the key of entry e of P; an error
condition occurs if k is invalid (that is, k
cannot be compared with other keys).
replaceValue(e,x): Replace with x and
return the value of entry e of P.

Priority Queues 38
Example
Operation Output P
insert(5,A) e1 (5,A)
insert(3,B) e2 (3,B),(5,A)
insert(7,C) e3 (3,B),(5,A),(7,C)
min() e2 (3,B),(5,A),(7,C)
key(e2) 3 (3,B),(5,A),(7,C)
remove(e1) e1 (3,B),(7,C)
replaceKey(e2,9) 3 (7,C),(9,B)
replaceValue(e3,D) C (7,D),(9,B)
remove(e2) e2 (7,D)
Phạm Bảo Sơn - DSA
Priority Queues 39
Locating Entries
In order to implement the operations
remove(k), replaceKey(e), and
replaceValue(k), we need fast ways of
locating an entry e in a priority queue.
We can always just search the entire
data structure to find an entry e, but
there are better ways for locating
entries.
Phạm Bảo Sơn - DSA
Priority Queues 40
Location-Aware Entries
A locator-aware entry identifies and tracks
the location of its (key, value) object within a
data structure
Intuitive notion:

Coat claim check

Valet claim ticket

Reservation number
Main idea:

Since entries are created and returned from the
data structure itself, it can return location-aware
entries, thereby making future updates easier
Priority Queues 41
List Implementation
A location-aware list entry is an object storing

key

value

position (or rank) of the item in the list
In turn, the position (or array cell) stores the entry
Back pointers (or ranks) are updated during swaps

header nodes/positions trailer

2 c 4 c 5 c 8 c

entries
Phạm Bảo Sơn - DSA
Priority Queues 42
Heap Implementation
A location-aware heap 2 d
entry is an object
storing 4 a 6 b

key

value

position of the entry in
the underlying heap
In turn, each heap
position stores an entry
Back pointers are
updated during entry
swaps 8 g 5 e 9 c

Priority Queues 43
Performance
Using location-aware entries we can achieve
the following running times (times better than
those achievable without location-aware
entries are highlighted in red):
Method Unsorted List Sorted List Heap
size, isEmpty O(1) O(1) O(1)
insert O(1) O(n) O(log n)
min O(n) O(1) O(1)
removeMin O(n) O(1) O(log n)
remove O(1) O(1) O(log n)
replaceKey O(1) O(n) O(log n)
replaceValue O(1) O(1) O(1)
Phạm Bảo Sơn - DSA
Priority Queues 44