|
|
| Line 1: |
Line 1: |
| {{more footnotes|date=October 2013}}
| | They call me Annalee although I don't enjoy being named that way Virginia is where his property is Workplace supervising is how my children is supported by me I am genuinely keen on to play with dogs but I battle to discover time for it.<br><br>Here is my weblog ... [http://archive.sg.com.mx/sgemprende/node/51469 cabbage-soup-diet] |
| In [[computer science]]/data structure, a '''priority queue''' is an [[abstract data type]] which is like a regular [[queue (data structure)|queue]] or [[stack (data structure)|stack]] data structure, but where additionally each element has a "priority" associated with it. In a priority queue, an element with high priority is served before an element with low priority. If two elements have the same priority, they are served according to their order in the queue.
| |
| | |
| A priority queue is not a [[Heap (data structure)|heap]]. A priority queue is an abstract concept like "a list" or "a map"; just as a list can be implemented with a [[linked list]] or an [[Array data structure|array]], a priority queue can be implemented with a heap or a variety of other methods.
| |
| | |
| == Operations ==
| |
| | |
| A priority queue must at least support the following operations:
| |
| | |
| * ''insert_with_priority'': add an [[element (mathematics)|element]] to the [[Queue (data structure)|queue]] with an associated priority.
| |
| * ''pull_highest_priority_element'': remove the element from the queue that has the ''highest priority'', and return it.
| |
| *: This is also known as "''pop_element(Off)''", "''get_maximum_element''" or "''get_front(most)_element''".
| |
| *: Some conventions reverse the order of priorities, considering lower values to be higher priority, so this may also be known as "''get_minimum_element''", and is often referred to as "''get-min''" in the literature.
| |
| *: This may instead be specified as separate "''peek_at_highest_priority_element''" and "''delete_element''" functions, which can be combined to produce "''pull_highest_priority_element''".
| |
| | |
| In addition, ''[[Peek (data type operation)|peek]]'' (in this context often called ''find-max'' or ''find-min''), which returns the highest-priority element but does not modify the queue, is very frequently implemented, and nearly always executes in [[Big O notation|''O''(1)]] time. This operation and its ''O''(1) 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.
| |
| | |
| == Similarity to queues ==
| |
| | |
| One can imagine a priority queue as a modified [[queue (data structure)|queue]], but when one would get the next element off the queue, the highest-priority element is retrieved first.
| |
| | |
| * ''stack'' – elements are pulled in [[LIFO (computing)|last-in first-out]]-order (e.g., a stack of papers)
| |
| * ''queue'' – elements are pulled in [[first-in first-out]]-order (e.g., a line in a cafeteria)
| |
| | |
| Stacks and queues may be modeled as particular kinds of priority queues. 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. (In [[big O notation|big ''O'' notation]]: ''O''(1) insertion time, ''O''(''n'') pull time due to search.)
| |
| | |
| === Usual implementation ===
| |
| | |
| To improve performance, priority queues typically use a [[Heap (data structure)|heap]] as their backbone, giving ''O''(log ''n'') performance for inserts and removals, and ''O''(''n'') to build initially. Alternatively, when a [[self-balancing binary search tree]] is used, insertion and removal also take ''O''(log ''n'') time, although building trees from existing sequences of elements takes ''O''(''n'' log ''n'') time; this is typical where one might already have access to these data structures, such as with third-party or standard libraries.
| |
| | |
| Note that from a computational-complexity standpoint, priority queues are congruent to sorting algorithms. See [[priority queue#Equivalence_of_priority_queues_and_sorting_algorithms|the next section]] for how efficient sorting algorithms can create efficient priority queues.
| |
| | |
| There are several specialized [[heap (data structure)|heap]] [[data structures]] that either supply additional operations or outperform these approaches. The [[binary heap]] uses ''O''(log ''n'') time for both operations, but also allows queries of the element of highest priority without removing it in constant time. [[Binomial heap]]s add several more operations, but require ''O''(log ''n'') time for requests. [[Fibonacci heap]]s can insert elements, query the highest priority element, and increase an element's priority in [[amortized analysis|amortized]] constant time,<ref name="CLRS">[[Thomas H. Cormen]], [[Charles E. Leiserson]], [[Ronald L. Rivest]], and [[Clifford Stein]]. ''[[Introduction to Algorithms]]'', Second Edition. [[MIT Press]] and McGraw-Hill, 2001. ISBN 0-262-03293-7. Chapter 20: Fibonacci Heaps, pp.476–497. Third edition p518.</ref> though deletions are still ''O''(log ''n''). [[Brodal queue]]s can do this in worst-case constant time.
| |
| | |
| While relying on a heap is a common way to implement priority queues, for integer data, faster implementations exist. This can even apply to data types that have a finite range, such as floats:
| |
| | |
| * When the set of keys is {1, 2, ..., ''C''}, a [[van Emde Boas tree]] would support the ''[[minimum]]'', ''[[maximum]]'', ''insert'', ''delete'', ''search'', ''[[extract-min]]'', ''[[extract-max]]'', ''[[predecessor]]'' and ''[[successor (graph theory)|successor]]'' operations in ''O''(log log ''C'') time, but has a space cost for small queues of about ''O''(2<sup>''m''/2</sup>), where ''m'' is the number of bits in the priority value.<ref>P. van Emde Boas. Preserving order in a forest in less than logarithmic time. In ''Proceedings of the 16th Annual Symposium on Foundations of Computer Science'', pages 75-84. IEEE Computer Society, 1975.</ref>
| |
| * The [[Fusion tree]] algorithm by [[Michael Fredman|Fredman]] and Willard implements the ''minimum'' operation in ''O''(1) time and ''insert'' and ''extract-min'' operations in <math>O(\sqrt{\log n})</math> time.<ref>[[Michael Fredman|Michael L. Fredman]] and Dan E. Willard. Surpassing the information theoretic bound with fusion trees. ''Journal of Computer and System Sciences'', 48(3):533-551, 1994</ref>
| |
| | |
| For applications that do many "[[Peek (data type operation)|peek]]" operations for every "extract-min" operation, the time complexity for peek actions can be reduced to ''O''(1) 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.
| |
| | |
| == Equivalence of priority queues and sorting algorithms ==
| |
| | |
| === Using a priority queue to sort ===
| |
| | |
| The [[operational semantics|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 algorithm]]s, once the layer of [[abstraction (computer science)|abstraction]] provided by the priority queue is removed. This sorting method is equivalent to the following sorting algorithms:
| |
| | |
| * [[Heapsort]] if the priority queue is implemented with a heap.
| |
| * [[Smoothsort]] if the priority queue is implemented with a Leonardo heap.
| |
| * [[Selection sort]] if the priority queue is implemented with an unordered array.
| |
| * [[Insertion sort]] if the priority queue is implemented with an ordered array.
| |
| * [[Tree sort]] if the priority queue is implemented with a [[self-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:<ref>{{cite doi|10.1145/1314690.1314692}}</ref>
| |
| | |
| <blockquote>
| |
| 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''(''n'') time per key, then there is a priority queue supporting ''delete'' and ''insert'' in ''O''(''S''(''n'')) time and ''find-min'' in constant time.
| |
| </blockquote>
| |
| | |
| That is, if there is a sorting algorithm which can sort in ''O''(''S'') time per key, where ''S'' is some function of ''n'' and [[word size]],<ref>http://courses.csail.mit.edu/6.851/spring07/scribe/lec17.pdf</ref> then one can use the given procedure to create a priority queue where pulling the highest-priority element is ''O''(1) time, and inserting new elements (and deleting elements) is ''O''(''S'') time. For example, if one has an ''O''(''n'' log log ''n'') sort algorithm, one can create a priority queue with ''O''(1) pulling and ''O''(''n'' log log ''n'') insertion.
| |
| | |
| == Libraries ==
| |
| | |
| A priority queue is often considered to be a "[[container (data structure)|container data structure]]".
| |
| | |
| The [[Standard Template Library]] (STL), and the [[C++]] 1998 standard, specifies <code>priority_queue</code> as one of the STL [[container (programming)|container]] [[adaptor (programming)|adaptor]] [[Template (programming)|class template]]s. It implements a max-priority-queue. Unlike actual STL containers, it does not allow [[Iterator|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 (C++ libraries)]] also have an implementation in the library heap.
| |
| | |
| Python's [http://docs.python.org/library/heapq.html heapq] module implements a binary min-heap on top of a list.
| |
| | |
| [[Java (programming language)|Java]]'s library contains a {{Javadoc:SE|java/util|PriorityQueue}} class, which implements a min-priority-queue.
| |
| | |
| [[Go (programming language)|Go]]'s library contains a [http://golang.org/pkg/container/heap/ container/heap] module, which implements a min-heap on top of any compatible data structure.
| |
| | |
| The [[Standard PHP Library]] extension contains the class [http://us2.php.net/manual/en/class.splpriorityqueue.php SplPriorityQueue].
| |
| | |
| Apple's [[Core Foundation]] framework contains a [http://developer.apple.com/library/mac/#documentation/CoreFoundation/Reference/CFBinaryHeapRef/Reference/reference.html CFBinaryHeap] structure, which implements a min-heap.
| |
| | |
| == Applications ==
| |
| | |
| === Bandwidth management ===
| |
| | |
| Priority queuing can be used to manage limited resources such as [[Bandwidth (computing)|bandwidth]] on a transmission line from a [[computer network|network]] [[router (computing)|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 [[Real-time Transport Protocol|RTP]] stream of a [[Voice over Internet Protocol|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 Network]]s 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 line communication|power lines]], phone lines and [[Ethernet over coax|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 Systems, Inc.|Cisco]] [[Callmanager]], which can be programmed to inhibit calls which would exceed the programmed bandwidth limit.
| |
| <!-- this was marked IMHO in the original
| |
| Priority queues exist on ISO-layer 2 (which is ethernet or WAN interfaces such as T1 / E1) and are filled by entry-criterions such as [[Diffserv]] Codepoints or IP-Precedence. Network equipment usually can be programmed to pick up prio packets by the layer 4 info (IP protocol and port) or the new one by a mechanism called [[NBAR]].
| |
| -->
| |
| | |
| === 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.
| |
| | |
| === Huffman coding ===
| |
| | |
| [[Huffman coding]] requires one to repeatedly obtain the two lowest-frequency trees. A priority queue makes this efficient.
| |
| | |
| === A* and SMA* search algorithms ===
| |
| | |
| The [[A* search algorithm]] finds the shortest path between two [[vertex (graph theory)|vertices]] or [[Node (graph theory)|nodes]] of a [[weighted graph]], trying out the most promising routes first. The priority queue (also known as the ''fringe'') is used to keep track of unexplored routes; the one for which a lower bound on the total path length is smallest is given highest priority. If memory limitations make [[A*]] impractical, 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.
| |
| | |
| == See also ==
| |
| | |
| * [[Batch queue]]
| |
| * [[Command queue]]
| |
| * [[Job scheduler]]
| |
| | |
| == References ==
| |
| | |
| {{Reflist}}
| |
| | |
| == Further reading ==
| |
| | |
| * [[Thomas H. Cormen]], [[Charles E. Leiserson]], [[Ronald L. Rivest]], and [[Clifford Stein]]. ''[[Introduction to Algorithms]]'', Second Edition. MIT Press and McGraw-Hill, 2001. ISBN 0-262-03293-7. Section 6.5: Priority queues, pp. 138–142.
| |
| | |
| == External links ==
| |
| | |
| * [http://en.cppreference.com/w/cpp/container/priority_queue C++ reference for <code>std::priority_queue</code>]
| |
| * [http://leekillough.com/heaps/ Descriptions] by [[Lee Killough (programmer)|Lee Killough]]
| |
| * [http://bitbucket.org/trijezdci/pqlib/src/ PQlib] - Open source Priority Queue library for C
| |
| * [http://github.com/vy/libpqueue libpqueue] is a generic priority queue (heap) implementation (in C) used by the Apache HTTP Server project.
| |
| * [http://www.theturingmachine.com/algorithms/heaps.html Survey of known priority queue structures] by Stefan Xenos
| |
| * [http://video.google.com/videoplay?docid=3499489585174920878 UC Berkeley - Computer Science 61B - Lecture 24: Priority Queues] (video) - introduction to priority queues using binary heap
| |
| | |
| {{Data structures}}
| |
| | |
| [[Category:Priority queues| ]]
| |
| [[Category:Abstract data types]]
| |