version 1.01
TCSS 342, Winter 2006Lecture Notes
Priority QueuesHeaps
2
Objectives Discuss the Priority Queue ADT Discuss implementations of the PQ Learn about Heaps See how Heaps can implement a
priority queue.
3
Priority Queue ADT A simple collection of objects with the
following main operations: addElement removeMin
Motivating examples: Banks managing customer information
Often will remove or get the information about the customer with the minimum bank account balance
Shared Printer queue list of print jobs, must get next job with highest priority,
and higher-priority jobs always print before lower-priority jobs
addElement removeMin
6 2 15 23 12 18 45 3 7
4
Simple implementationsof the Priority Queue ADT
addElement
removeMin
(unsorted) list
sorted list
BST
AVL tree(overkill?)
5
Discussion of implementations
list: store all in an unordered list, remove min/max one by searching for it problem: expensive to search
sorted list: store all in a sorted list, then search it in O(log n) time with binary search problem: expensive to add/remove
binary tree: store in a BST, search it in O(log n) time for the min (leftmost) element problem: tree could be unbalanced on nonrandom
input balanced BST
good for O(log n) inserts and removals, but is there a better way?
6
Priority queue ADT priority queue: an collection of ordered
elements that provides fast access to the minimum (or maximum) element a mix between a queue and a BST often implemented with a heap
priority queue operations (using minimum): add
O(1) average, O(log n) worst-case getMin- returns Min w/o removing it
O(1) removeMin- returns Min and removes it
O(log n) worst-case isEmpty, clear, size, iterator
O(1)
7
Heaps and priority queues 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:
8
Heaps and priority queues 2
2. heap orderinga 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 a heap a BST?
These are min-heaps;Can also have max-heaps.
9
Which are min-heaps?
1530
8020
10
996040
8020
10
50 700
85
996040
8020
10
50 700
85
996040
8010
20
50 700
85
996040
8020
10
6040
8020
10
10
24
7 3
30
10 40
30
80
2510
48
21
14
10 17
33
91828
11
22
3530
50
30
10 20
wrong!
wrong!
Which are max-heaps?
11
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!
996040
8020
10
50 700
85
65
996040
8020
10
50 700
85
65 15
12
Adding to a heap, cont'd. to restore heap ordering property, the
newly added element must be shifted upward ("bubbled up") until it reaches its proper place bubble up (book: "percolate up") by swapping with
parent how many bubble-ups could be necessary, at most?
996040
8020
10
50 700
85
65 15
992040
8015
10
50 700
85
65 60
13
Adding to a max-heap
16
5 11
3 18
16
18 11
3 5
18
16 11
3 5
same operations, but must bubble up larger values to top
14
The getMin operation getMin on a min-heap is trivial; because
of the heap properties, the minimum element is always the root getMin is O(1)
996040
8020
10
50 700
85
65
15
Removing from a min-heap
min-heaps only support removeMin; min is the root must remove the root while maintaining heap
completeness and ordering properties intuitively, the last leaf must disappear to keep it a
heap initially, just swap root with last leaf (we'll fix it)
996040
8020
10
50 700
85
65
996040
8020
65
50 700
85
65
16
Removing from a heap, cont'd.
must fix heap-ordering property; root is out of order shift the root downward ("bubble down") until it's in
place swap it with its smaller child each time
996040
8020
65
700 50
85 996050
8040
20
700 65
85
17
Heap height and runtime height of a complete tree is always log n,
because it is always balanced this suggests that searches, adds, and
removes will have O(log n) worst-case runtime
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 treeof height h: h = log n2h n 2h+1 - 1
18
Creating large heaps Can insert all items into a heap one at a time.
What is run-time cost of this approach? Or, can recursive create a heap from an
initial set of n items: Start with complete tree Create heap out of left subtree of root Create heap out of right subtree of root Bubble root down to create heap out of whole
tree. Also can use an iterative technique
(discussed next).
19
Turning any input into a heap
we can quickly turn any complete tree of comparable elements into a heap with a buildHeap algorithm
simply "bubble down" on every node that is not a leaf, starting from the lowest levels upward. Convenient to work from right to left. why does this buildHeap operation work? how long does it take to finish? (big-Oh)
66014
1821
45
32 456021
1814
6
32
20
Implementation of a heap when implementing a complete binary
tree, more efficient to use array implementation index of root = 1 (leave 0 empty for
simplicity) for any node n at index i,
index of n.left = 2i index of n.right = 2i + 1
21
Advantages of array heap the "implicit representation" of a heap in an
array makes several operations very fast add a new node at the end (O(1)) from a node, find its parent (O(1)) swap parent and child (O(1)) a lot of dynamic memory allocation of tree
nodes is avoided the algorithms shown usually have elegant
solutions
private void buildHeap() { for (int i = size()/2; i > 0; i--) bubbleDown(i); }
22
Heap sort heap sort: an algorithm to sort an array
of N elements by turning the array into a heap, then doing a removeMin N times the elements will come out in sorted order! we can put them into a new sorted array what is the runtime?
23
A max-heap
So far have been examining min-heaps, where minimum item is at root.
a max-heap is the same thing, but with the items in reverse order max item is at root.
24
Improved heap sort
Heapsort using min-heap requires two arrays One for heap one for storing results as min is pulled out.
Use a max-heap to implement an improved heap sort that needs no extra storage O(n log n) runtime no external storage required! useful on low-memory devices elegant
25
Improved heap sort 1 use an array heap, but with 0 as the root
index max-heap state after buildHeap
operation:
26
Improved heap sort 2
state after one removeMin operation: modified removeMin that moves element to
end
27
Improved heap sort 3
state after two removeMin operations: notice that the largest elements are at the
end(becoming sorted!)
28
Sorting algorithms review
Best case Average case (†) Worst caseSelection sort n2 n2 n2
Bubble sort n n2 n2
Insertion sort n n2 n2
Mergesort n log 2 n n log 2 n n log 2 nHeapsort n log 2 n n log 2 n n log 2 nTreesort n log 2 n n log 2 n n2
Quicksort n log 2 n n log 2 n n2
† According to Knuth, the average growth rate of Insertion sort is about
0.9 times that of Selection sort and about 0.4 times that of Bubble Sort. Also, the average growth rate of Quicksort is about 0.74 times that of Mergesort and about 0.5 times that of Heapsort.
29
Other PQ Operations decreaseKey(p, ): bubble up increaseKey(p, ): bubble down remove(p): decreaseKey(p, ) deleteMin()Running time: O(log N)
findMax: O(N).
30
References
Lewis & Chase book, chapter 15.