CSE 373
Data Structures and Algorithms
Lecture 13: Priority Queues (Heaps)
Motivating Examples
Bandwidth management: A router is connected to a line with limited
bandwidth. If there is insufficient bandwidth, the router maintains a queue
for incoming data such that the most important data will get forwarded
first as bandwidth becomes available.
Printing: A shared server has a list of print jobs to print. It wants to print
them in chronological order, but each print job also has a priority, and
higher-priority jobs always print before lower-priority jobs
Algorithms: We are writing a ghost AI algorithm for Pac-Man. It needs to
search for the best path to find Pac-Man; it will enqueue all possible paths
with priorities (based on guesses about which one will succeed), and try
them in order.
Priority Queue ADT
priority queue: A collection of elements that provides
fast access to the minimum (or maximum) element
basic priority queue operations:
a mix between a queue and a BST
insert: Add an element to the priority queue (priority matters)
remove (i.e. deleteMin): Removes/returns minimum element
Using PriorityQueues
PriorityQueue<E>() constructs a PriorityQueue that orders the
elements according to their compareTo
(element type must implement Comparable)
add(element)
inserts the element into the PriorityQueue
remove()
removes and returns the element at the head
of the queue
peek()
returns, but does not remove, the element at
the head of the queue
Queue<String> pq = new PriorityQueue<String>();
pq.add("Kona");
pq.add("Daisy");
implements Queue interface
PriorityQueue in Java is a concrete class
Potential Implementations
insert
Unsorted list (Array)
Unsorted list (Linked-List)
Sorted list (Array)
Sorted list (Linked-List)
Binary Search Tree
AVL Trees
5
deleteMin
Potential Implementations
insert
deleteMin
Unsorted
list
(Array)
(1)
(n)
Unsorted
list
(Linked-List)
(1)
(n)
Sorted
list
(Array)
(n)
(1)*
Sorted
list
(Linked-List)
(n)
(1)
Binary
Search
Tree
(n)
worst
(n)
worst
AVL
Trees
(log
n)
(log
n)
* Assume sorted array has lowest priority value item last
6
Heap properties
heap: a tree with the following two properties:
1. completeness
complete tree: every level is full except possibly the lowest
level, which must be filled from left to right with no leaves to
the right of a missing node (i.e., a node may not have any
children until all of its possible siblings exist)
Heap shape:
Heap properties 2
2. heap ordering
a tree has heap ordering if P <= X for every element X with
parent P
In other words, in heaps, parents' element values are always smaller
than those of their children
Implies that minimum element is always the root
Is every heap a BST? Are any heaps BSTs?
Which are min-heaps?
10
20
30
10 wrong!
wrong!
20
80
40
15
20
40
50 700
9
80
60
85
99
700
80
60
10
85
50
10
20wrong!
40
60
20
40
99
10 wrong!
20
80
60
85
50 700
10
99
80
40
80
60
99
Which are max-heaps?
wrong!
30
10
48
21
20
80
10
25
14
24
10
17
3
50
30
33
10
30
10
30
40
22
wrong!
11
35
28
18
Heap height and runtime
height of a complete tree is always log n, because it is always
balanced
because of this, if we implement a priority queue using a
heap, we can provide the O(log n) runtime required for the
add and remove operations
n-node
complete tree
of height h:
2h n 2h+1 1
h = log n
11
Implementation of a heap
when implementing a complete binary tree, we actually can
"cheat" and just use an array
index of root = 1 (leave 0 empty for simplicity)
for any node n at index i,
12
index of n.left = 2i
index of n.right = 2i + 1
parent index?
Implementing Priority Queue: Binary Heap
public interface IntPriorityQueue {
public void add(int value);
public boolean isEmtpy();
public int peek();
public int remove();
}
public class IntBinaryHeap implements IntPriorityQueue {
private static final int DEFAULT_CAPACITY = 10;
private int[] array;
private int size;
public IntBinaryHeap () {
array = new int[DEFAULT_CAPACITY];
size = 0;
}
...
}
13
Adding to a heap
when an element is added to a heap, it should be initially
placed as the rightmost leaf (to maintain the
completeness property)
heap ordering property becomes broken!
10
20
40
50
14
700
10
80
60
65
85
20
99
40
50
700
80
60
65
85
15
99
Adding to a heap, cont'd.
to restore heap ordering property, the newly added
element must "bubble up until it reaches its proper place
bubble up (or "percolate up") by swapping with parent
how many bubble-ups could be necessary, at most?
10
20
40
50
15
700
10
80
60
65
85
15
15
99
40
50
700
80
20
65
85
60
99
Adding to a max-heap
same operations, but must bubble up larger values to top
16
16
5
18
16
18
11
3
18
11
16
3
11
Heap practice problem
Draw the state of the min-heap tree after adding the
following elements to it:
6, 50, 11, 25, 42, 20, 104, 76, 19, 55, 88, 2
17
