6.6 KiB
Lecture 23 --- Priority Queues
Today’s Lecture
- Definition of a Binary Heap
- What’s a Priority Queue?
- A Priority Queue as a Heap
- A Heap as a Vector
24.1 Priority Queue
- Priority queues are used in prioritizing operations. Examples include a personal “to do” list, what order to do homework assignments, jobs on a shop floor, packet routing in a network, scheduling in an operating system, or events in a simulation.
- Among the data structures we have studied, their interface is most similar to a queue, including the idea of a front or top and a tail or a back.
- Each item is stored in a priority queue using an associated “priority” and therefore, the top item is the one with the lowest value of the priority score. The tail or back is never accessed through the public interface to a priority queue.
- The main operations are insert or push, and pop (or delete_min).
24.2 Some Data Structure Options for Implementing a Priority Queue
-
Vector or list, either sorted or unsorted
– At least one of the operations, push or pop, will cost linear time, at least if we think of the container as a linear structure.
-
Binary search trees
– If we use the priority as a key, then we can use a combination of finding the minimum key and erase to implement pop. An ordinary binary-search-tree insert may be used to implement push.
– This costs logarithmic time in the average case (and in the worst case as well if balancing is used).
-
The latter is the better solution, but we would like to improve upon it — for example, it might be more natural if the minimum priority value were stored at the root.
24.3 Definition: Binary Heaps
-
A binary heap is a complete binary tree such that at each internal node, p, the value stored is less than the value stored at either of p’s children.
– A complete binary tree is one that is completely filled, except perhaps at the lowest level, and at the lowest level all leaf nodes are as far to the left as possible.
-
Binary heaps will be drawn as binary trees, but implemented using vectors!
-
Alternatively, the heap could be organized such that the value stored at each internal node is greater than the values at its children.
24.4 Exercise: Drawing Binary Heaps
-
Draw two different binary heaps with these values: 52 13 48 7 32 40 18 25 4
-
Draw several other trees with these values which are not binary heaps.
24.5 STL priority_queue
- The standard library (STL) priority_queue is implemented as a binary heap.
- The STL priority_queue is a max heap.
- You need to include <queue> in order to use the STL priority_queue. Below is a simple example:
#include <iostream>
#include <queue>
int main() {
std::priority_queue<int> maxHeap;
maxHeap.push(3);
maxHeap.push(4);
maxHeap.push(3);
maxHeap.push(1);
maxHeap.push(5);
while (!maxHeap.empty()) {
std::cout << maxHeap.top() << " ";
maxHeap.pop();
}
std::cout << std::endl;
return 0;
}
- The above program will print:
5 4 3 3 1
- When using std::priority_queue to store class objects, oftentimes, you need to define a class and overload its function call operator.
- You can use std::priority_queue as a min heap via using std::greater, as can be seen in this example:
#include <iostream>
#include <queue>
int main() {
std::priority_queue<int, std::vector<int>, std::greater<int>> minHeap;
minHeap.push(3);
minHeap.push(4);
minHeap.push(3);
minHeap.push(1);
minHeap.push(5);
while (!minHeap.empty()) {
std::cout << minHeap.top() << " ";
minHeap.pop();
}
std::cout << std::endl;
return 0;
}
- This above program will print:
1 3 3 4 5