Here is a conceptual picture of a priority queue:
Think of a priority queue as a kind of bag that holds priorities. You can put one in, and you can take out the current highest priority. (Priorities can be any Comparable values; in our examples, we'll just use numbers.)
A priority queue is different from a "normal" queue, because instead of being a "first-in-first-out" data structure, values come out in order by priority. A priority queue might be used, for example, to handle the jobs sent to the Computer Science Department's printer: Jobs sent by the department chair should be printed first, then jobs sent by professors, then those sent by graduate students, and finally those sent by undergraduates. The values put into the priority queue would be the priority of the sender (e.g., using 4 for the chair, 3 for professors, 2 for grad students, and 1 for undergrads), and the associated information would be the document to print. Each time the printer is free, the job with the highest priority would be removed from the print queue, and printed. (Note that it is OK to have multiple jobs with the same priority; if there is more than one job with the same highest priority when the printer is free, then any one of them can be selected.)
The operations that need to be provided for a priority queue are shown in the following table, assuming that just priorities (no associated information) are to be stored in a priority queue.
OPERATION | DESCRIPTION |
PriorityQ() | (constructor) create an empty priority queue |
boolean empty() | return true iff the priority queue is empty |
void insert(Comparable p) | add priority p to the priority queue |
Comparable removeMax() | remove and return the highest priority from the priority queue (error if the priority queue is empty) |
Consider implementing a priority queue using an array, a linked list, or a BST. For each, describe how each of the priority queue operations would be implemented, and what the worst-case time would be.
A heap is a binary tree (in which each node contains a Comparable key value), with two special properties:
The ORDER property:
The SHAPE property:
And here are some more trees; they all have the shape property, but some violate the order property:
Now let's consider how to implement priority queues using a heap. The standard approach is to use an array (or an ArrayList), starting at position 1 (instead of 0), where each item in the array corresponds to one node in the heap:
Note that the heap's "shape" property guarantees that there are never any "holes" in the array.
The operations that create an empty heap and return the size of the heap are quite straightforward; below we discuss the insert and removeMax operations.
When a new value is inserted into a priority queue, we need to:
Insert the values 6, 40, and 28 into the tree shown above (after 34 has been inserted).
Because heaps have the order property, the largest value is always at the root. Therefore, the removeMax operation will always remove and return the root value; the question then is how to replace the root node so that the heap still has the order and shape properties.
The answer is to use the following algorithm:
Perform 3 more removeMax operations using the example tree.
For the insert operation, we start by adding a value to the end of the array (constant time, assuming the array doesn't have to be expanded); then we swap values up the tree until the order property has been restored. In the worst case, we follow a path all the way from a leaf to the root (i.e., the work we do is proportional to the height of the tree). Because a heap is a balanced binary tree, the height of the tree is O(log N), where N is the number of values stored in the tree.
The removeMax operation is similar: in the worst case, we follow a path down the tree from the root to a leaf. Again, the worst-case time is O(log N).
A priority queue is a data structure that stores priorities (comparable values) and perhaps associated information. A priority queue supports inserting new priorities, and removing/retrning the highest priority. When a priority queue is implemented using a heap, the worst-case times for both insert and removeMax are logarithmic in the number of values in the priority queue.