Priority queue


In computer science, a priority queue is an abstract data type similar to regular queue or stack data structure in which each element additionally has a "priority" associated with it. In a priority queue, an element with high priority is served before an element with low priority. In some implementations, if two elements have the same priority, they are served according to the order in which they were enqueued, while in other implementations, ordering of elements with the same priority is undefined.
While priority queues are often implemented with heaps, they are conceptually distinct from heaps. A priority queue is a concept like "a list" or "a map"; just as a list can be implemented with a linked list or an array, a priority queue can be implemented with a heap or a variety of other methods such as an unordered array.

Operations

A priority queue must at least support the following operations:
In addition, peek, which returns the highest-priority element but does not modify the queue, is very frequently implemented, and nearly always executes in O time. This operation and its O performance is crucial to many applications of priority queues.
More advanced implementations may support more complicated operations, such as pull_lowest_priority_element, inspecting the first few highest- or lowest-priority elements, clearing the queue, clearing subsets of the queue, performing a batch insert, merging two or more queues into one, incrementing priority of any element, etc.
One can imagine a priority queue as a modified queue, but when one would get the next element off the queue, the highest-priority element is retrieved first.
Stacks and queues may be modeled as particular kinds of priority queues. As a reminder, here is how stacks and queues behave:
In a stack, the priority of each inserted element is monotonically increasing; thus, the last element inserted is always the first retrieved. In a queue, the priority of each inserted element is monotonically decreasing; thus, the first element inserted is always the first retrieved.

Implementation

Naive implementations

There are a variety of simple, usually inefficient, ways to implement a priority queue. They provide an analogy to help one understand what a priority queue is. For instance, one can keep all the elements in an unsorted list. Whenever the highest-priority element is requested, search through all elements for the one with the highest priority. insertion time, O

Usual implementation

To improve performance, priority queues typically use a heap as their backbone, giving O performance for inserts and removals, and O to build initially from a set of n elements. Variants of the basic heap data structure such as pairing heaps or Fibonacci heaps can provide better bounds for some operations.
Alternatively, when a self-balancing binary search tree is used, insertion and removal also take O time, although building trees from existing sequences of elements takes O time; this is typical where one might already have access to these data structures, such as with third-party or standard libraries.
From a computational-complexity standpoint, priority queues are congruent to sorting algorithms. The section on the equivalence of priority queues and sorting algorithms, below, describes how efficient sorting algorithms can create efficient priority queues.

Specialized heaps

There are several specialized heap data structures that either supply additional operations or outperform heap-based implementations for specific types of keys, specifically integer keys. Suppose the set of possible keys is.
For applications that do many "peek" operations for every "extract-min" operation, the time complexity for peek actions can be reduced to O in all tree and heap implementations by caching the highest priority element after every insertion and removal. For insertion, this adds at most a constant cost, since the newly inserted element is compared only to the previously cached minimum element. For deletion, this at most adds an additional "peek" cost, which is typically cheaper than the deletion cost, so overall time complexity is not significantly impacted.
Monotone priority queues are specialized queues that are optimized for the case where no item is ever inserted that has a lower priority than any item previously extracted. This restriction is met by several practical applications of priority queues.

Summary of running times

Equivalence of priority queues and sorting algorithms

Using a priority queue to sort

The semantics of priority queues naturally suggest a sorting method: insert all the elements to be sorted into a priority queue, and sequentially remove them; they will come out in sorted order. This is actually the procedure used by several sorting algorithms, once the layer of abstraction provided by the priority queue is removed. This sorting method is equivalent to the following sorting algorithms:
NamePriority Queue ImplementationBestAverageWorst
HeapsortHeap
SmoothsortLeonardo Heap
Selection sortUnordered Array
Insertion sortOrdered Array
Tree sortSelf-balancing binary search tree

Using a sorting algorithm to make a priority queue

A sorting algorithm can also be used to implement a priority queue. Specifically, Thorup says:

We present a general deterministic linear space reduction from priority queues to sorting implying that if we can sort up to n keys in S time per key, then there is a priority queue supporting delete and insert in O time and find-min in constant time.

That is, if there is a sorting algorithm which can sort in O time per key, where S is some function of n and word size, then one can use the given procedure to create a priority queue where pulling the highest-priority element is O time, and inserting new elements is O time. For example, if one has an O sort algorithm, one can create a priority queue with O pulling and O insertion.

Libraries

A priority queue is often considered to be a "container data structure".
The Standard Template Library, and the C++ 1998 standard, specifies priority_queue as one of the STL container adaptor class templates. However, it does not specify how two elements with same priority should be served, and indeed, common implementations will not return them according to their order in the queue. It implements a max-priority-queue, and has three parameters: a comparison object for sorting such as a function object, the underlying container for storing the data structures, and two iterators to the beginning and end of a sequence. Unlike actual STL containers, it does not allow iteration of its elements. STL also has utility functions for manipulating another random-access container as a binary max-heap. The Boost libraries also have an implementation in the library heap.
Python's module implements a binary min-heap on top of a list.
Java's library contains a class, which implements a min-priority-queue.
Scala's library contains a class, which implements a max-priority-queue.
Go's library contains a module, which implements a min-heap on top of any compatible data structure.
The Standard PHP Library extension contains the class .
Apple's Core Foundation framework contains a structure, which implements a min-heap.

Applications

Bandwidth management

Priority queuing can be used to manage limited resources such as bandwidth on a transmission line from a network router. In the event of outgoing traffic queuing due to insufficient bandwidth, all other queues can be halted to send the traffic from the highest priority queue upon arrival. This ensures that the prioritized traffic is forwarded with the least delay and the least likelihood of being rejected due to a queue reaching its maximum capacity. All other traffic can be handled when the highest priority queue is empty. Another approach used is to send disproportionately more traffic from higher priority queues.
Many modern protocols for local area networks also include the concept of priority queues at the media access control sub-layer to ensure that high-priority applications experience lower latency than other applications which can be served with best effort service. Examples include IEEE 802.11e and ITU-T G.hn.
Usually a limitation is set to limit the bandwidth that traffic from the highest priority queue can take, in order to prevent high priority packets from choking off all other traffic. This limit is usually never reached due to high level control instances such as the Cisco Callmanager, which can be programmed to inhibit calls which would exceed the programmed bandwidth limit.

Discrete event simulation

Another use of a priority queue is to manage the events in a discrete event simulation. The events are added to the queue with their simulation time used as the priority. The execution of the simulation proceeds by repeatedly pulling the top of the queue and executing the event thereon.
See also: Scheduling, queueing theory

Dijkstra's algorithm

When the graph is stored in the form of adjacency list or matrix, priority queue can be used to extract minimum efficiently when implementing Dijkstra's algorithm, although one also needs the ability to alter the priority of a particular vertex in the priority queue efficiently.

Huffman coding

requires one to repeatedly obtain the two lowest-frequency trees. A priority queue is one method of doing this.

Best-first search algorithms

algorithms, like the A* search algorithm, find the shortest path between two vertices or nodes of a weighted graph, trying out the most promising routes first. A priority queue is used to keep track of unexplored routes; the one for which the estimate of the total path length is smallest is given highest priority. If memory limitations make best-first search impractical, variants like the SMA* algorithm can be used instead, with a double-ended priority queue to allow removal of low-priority items.

ROAM triangulation algorithm

The Real-time Optimally Adapting Meshes algorithm computes a dynamically changing triangulation of a terrain. It works by splitting triangles where more detail is needed and merging them where less detail is needed. The algorithm assigns each triangle in the terrain a priority, usually related to the error decrease if that triangle would be split. The algorithm uses two priority queues, one for triangles that can be split and another for triangles that can be merged. In each step the triangle from the split queue with the highest priority is split, or the triangle from the merge queue with the lowest priority is merged with its neighbours.

Prim's algorithm for minimum spanning tree

Using min heap priority queue in Prim's algorithm to find the minimum spanning tree of a connected and undirected graph, one can achieve a good running time. This min heap priority queue uses the min heap data structure which supports operations such as insert, minimum, extract-min, decrease-key. In this implementation, the weight of the edges is used to decide the priority of the vertices. Lower the weight, higher the priority and higher the weight, lower the priority.

Parallel priority queue

Parallelization can be used to speed up priority queues. There are three different methods to parallelize priority queues. The easiest approach is to simply parallelize the individual operations, like insert or extractMin. Another method allows the concurrent access of multiple processes to the same priority queue. The last method uses operations that work on elements, instead of just one element. For example, extractMin will remove the first elements with the highest priority.

Parallelize individual operations

An easy way to parallelize priority queues is to parallelize the individual operations. That means, the queue works like a sequential one, but the individual operations are sped up by using several processors. The maximum Speedup for this technique is limited by because there are sequential implementations for priority queues whose slowest operation runs in .
The operations insert, extract-min, decrease-key and delete can be executed in constant time on a Concurrent Read, Exclusive Write PRAM with processors, where is the size of the priority queue. In the following the queue is implemented as binomial heap. After every operation only three trees of the same order are allowed and the smallest root of the trees of order is smaller than all roots of trees of higher order.
Below, pseudocode for insert is shown.
insert
parallelLink
extractMin
The concept for constant time insert and extract-min can be extended to achieve a constant time for delete as well. The decrease-key operation can then be implemented as delete and a following insert. So the decrease-key operation is also a constant time operation.
The advantage of this type of parallelizing the priority queue is, that it can be used like a usual sequential one. But the maximum speedup is only. This speedup is further limited in practice, because there is additional effort for the communication between the different processors.

Concurrent parallel access

If the priority queue allows concurrent access, multiple processes can perform operations concurrently on that priority queue. However, this raises two issues. First of all, the definition of the semantics of the individual operations is no longer obvious. For example, if two processes want to extract the element with the highest priority, should they get the same element or different ones? This restricts parallelism on the level of the program using the priority queue. In addition, because multiple processes have access to the same element, this leads to contention.
The concurrent access to a priority queue can be implemented on a Concurrent Read, Concurrent Write PRAM model. In the following the priority queue is implemented as a skip list. In addition, an atomic synchronization primitive, CAS, is used to make the skip list lock-free. The nodes of the skip list consists of a unique key, a priority, an array of pointers, for each level, to the next nodes and a delete mark. The delete mark marks if the node is about to be deleted by a process. This ensures that other processes can react to the deletion appropriately.
If the concurrent access to a priority queue is allowed, conflicts may arise between two processes. For example, a conflict arises if one process is trying to insert a new node, but at the same time another process is about to delete the predecessor of that node. There is a risk that the new node is added to the skip list, yet it is not longer reachable.

K-element operations

For this type of parallelization new operations are introduced, that operate on elements simultaneously instead of only one.
The new operation k_extract-min then deletes the smallest elements of the priority queue and returns those. The queue is parallelized on distributed memory. Each processor has its own local memory and a local priority queue. The elements of the global priority queue are distributed across all processors.
A k_insert operation assigns the elements uniformly random to the processors which insert the elements into their local queues. Note that single elements can still be inserted into the queue. Using this strategy the global smallest elements are in the union of the local smallest elements of every processor with high probability. Thus each processor holds a representative part of the global priority queue.
This property is used when k_extract-min is executed, as the smallest elements of each local queue are removed and collected in a result set. The elements in the result set are still associated with their original processor. The number of elements that is removed from each local queue depends on and the number of processors.
By parallel selection the smallest elements of the result set are determined. With high probability these are the global smallest elements. If not, elements are again removed from each local queue and put into the result set. This is done until the global smallest elements are in the result set. Now these elements can be returned. All other elements of the result set are inserted back into their local queues. The running time of k_extract-min is expected, where and
is the size of the priority queue.
The priority queue can be further improved by not moving the remaining elements of the result set directly back into the local queues after a k_extract-min operation. This saves moving elements back and forth all the time between the result set and the local queues.
By removing several elements at once a considerable speedup can be reached. But not all algorithms can use this kind of priority queue. Dijkstra's algorithm for example can not work on several nodes at once. The algorithm takes the node with the smallest distance from the priority queue and calculates new distances for all its neighbor nodes. If you would take out nodes, working at one node could change the distance of another one of the nodes. So using k-element operations destroys the label setting property of Dijkstra's algorithm.