Search Results for “priority queue”

Source: Priority queue

In computer science, a priority queue is an abstract data type similar to a regular queue or stack abstract data type. Each element in a priority queue has an associated priority. In a priority queue, elements with high priority are served before elements with low priority. In some implementations, if two elements have the same priority, they are served in the same order in which they were enqueued. In other implementations, the order of elements with the same priority is undefined.
While priority queues are often implemented using heaps, they are conceptually distinct from heaps. A priority queue is an abstract data type like a list or a map; just as a list can be implemented with a linked list or with an array, a priority queue can be implemented with a heap or another method such as an ordered array.

Operations

priority

Implementation

= Naive implementations

= Usual implementation

priority

= Specialized heaps

queue

priority

= Summary of running times

Equivalence of priority queues and sorting algorithms

= Using a priority queue to sort

= Using a sorting algorithm to make a priority queue

Libraries

if unspecified), the underlying container for storing the data structures (defaults to std::vector), and two iterators to the beginning and end of a sequence. Unlike actual STL containers, it does not allow iteration of its elements (it strictly adheres to its abstract data type definition). 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 heapq module implements a binary min-heap on top of a list.
Java's library contains a PriorityQueue class, which implements a min-priority-queue as a binary heap.
.NET's library contains a PriorityQueue class, which implements an array-backed, quaternary min-heap.
Scala's library contains a PriorityQueue class, which implements a max-priority-queue.
Go's library contains a container/heap module, which implements a min-heap on top of any compatible data structure.
The Standard PHP Library extension contains the class SplPriorityQueue.
Apple's Core Foundation framework contains a CFBinaryHeap 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 (such as real-time traffic, e.g. an RTP stream of a VoIP connection) 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 (MAC) sub-layer to ensure that high-priority applications (such as VoIP or IPTV) experience lower latency than other applications which can be served with best-effort service. Examples include IEEE 802.11e (an amendment to IEEE 802.11 which provides quality of service) and ITU-T G.hn (a standard for high-speed local area network using existing home wiring (power lines, phone lines and coaxial cables).
Usually a limitation (policer) 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 (computing), 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.
If instead, a graph is stored as node objects, and priority-node pairs are inserted into a heap, altering the priority of a particular vertex is not necessary if one tracks visited nodes. Once a node is visited, if it comes up in the heap again (having had a lower priority number associated with it earlier), it is popped-off and ignored.

= Huffman coding

=
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

=
Best-first search 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 (also known as the fringe) is used to keep track of unexplored routes; the one for which the estimate (a lower bound in the case of A*) 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 (ROAM) 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, but requires some changes to the priority queue interface. The reason for such changes is that a sequential update usually only has

O
(
1
)

{\textstyle O(1)}

or

O
(
log
⁡
n
)

{\textstyle O(\log n)}

cost, and there is no practical gain to parallelize such an operation. One possible change is to allow the concurrent access of multiple processors to the same priority queue. The second possible change is to allow batch operations that work on

k

{\textstyle k}

elements, instead of just one element. For example, extractMin will remove the first

k

{\textstyle k}

elements with the highest priority.

= 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 (CRCW) 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.

insert(e): First, a new node with a key and a priority is created. In addition, the node is assigned a number of levels, which dictates the size of the array of pointers. Then a search is performed to find the correct position where to insert the new node. The search starts from the first node and from the highest level. Then the skip list is traversed down to the lowest level until the correct position is found. During the search, for every level the last traversed node will be saved as parent node for the new node at that level. In addition, the node to which the pointer, at that level, of the parent node points towards, will be saved as the successor node of the new node at that level. Afterwards, for every level of the new node, the pointers of the parent node will be set to the new node. Finally, the pointers, for every level, of the new node will be set to the corresponding successor nodes.
extract-min: First, the skip list is traversed until a node is reached whose delete mark is not set. This delete mark is than set to true for that node. Finally the pointers of the parent nodes of the deleted node are updated.
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. (See image)

= K-element operations

=
In this setting, operations on a priority queue is generalized to a batch of

k

{\textstyle k}

elements.
For instance, k_extract-min deletes the

k

{\textstyle k}

smallest elements of the priority queue and returns those.
In a shared-memory setting, the parallel priority queue can be easily implemented using parallel binary search trees and join-based tree algorithms. In particular, k_extract-min corresponds to a split on the binary search tree that has

O
(
log
⁡
n
)

{\textstyle O(\log n)}

cost and yields a tree that contains the

k

{\textstyle k}

smallest elements. k_insert can be applied by a union of the original priority queue and the batch of insertions. If the batch is already sorted by the key, k_insert has

O
(
k
log
⁡
(
1
+

n
k

)
)

{\textstyle O(k\log(1+{\frac {n}{k}}))}

cost. Otherwise, we need to first sort the batch, so the cost will be

O
(
k
log
⁡
(
1
+

n
k

)
+
k
log
⁡
k
)
=
O
(
k
log
⁡
n
)

{\textstyle O(k\log(1+{\frac {n}{k}})+k\log k)=O(k\log n)}

. Other operations for priority queue can be applied similarly. For instance, k_decrease-key can be done by first applying difference and then union, which first deletes the elements and then inserts them back with the updated keys. All these operations are highly parallel, and the theoretical and practical efficiency can be found in related research papers.
The rest of this section discusses a queue-based algorithm on distributed memory. We assume each processor has its own local memory and a local (sequential) priority queue. The elements of the global (parallel) 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

m

{\textstyle m}

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

m

{\textstyle m}

that is removed from each local queue depends on

k

{\textstyle k}

and the number of processors

p

{\textstyle p}

.

By parallel selection the

k

{\textstyle k}

smallest elements of the result set are determined. With high probability these are the global

k

{\textstyle k}

smallest elements. If not,

m

{\textstyle m}

elements are again removed from each local queue and put into the result set. This is done until the global

k

{\textstyle k}

smallest elements are in the result set. Now these

k

{\textstyle k}

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

O
(

k
p

log
⁡
(
n
)
)

{\textstyle O({\frac {k}{p}}\log(n))}

, where

k
=
Ω
(
p
⋅
log
⁡
(
p
)
)

{\textstyle k=\Omega (p\cdot \log(p))}

and

n

{\textstyle n}

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

k

{\textstyle k}

nodes, working at one node could change the distance of another one of the

k

{\textstyle k}

nodes. So using k-element operations destroys the label setting property of Dijkstra's algorithm.

References

External links

C++ reference for std::priority_queue
Descriptions by Lee Killough
libpqueue is a generic priority queue (heap) implementation (in C) used by the Apache HTTP Server project.
Survey of known priority queue structures by Stefan Xenos
UC Berkeley - Computer Science 61B - Lecture 24: Priority Queues (video) - introduction to priority queues using binary heap