priority_queue Class

Article
07/11/2012

A template container adaptor class that provides a restriction of functionality limiting access to the top element of some underlying container type, which is always the largest or of the highest priority. New elements can be added to the priority_queue and the top element of the priority_queue can be inspected or removed.

template < 
   class Type,  
   class Container=vector<Type>, 
   class Compare=less<typename Container::value_type>  
> 
class priority_queue

Parameters

Type
The element data type to be stored in the priority_queue.
Container
The type of the underlying container used to implement the priority_queue.
Compare
The type that provides a function object that can compare two element values as sort keys to determine their relative order in the priority_queue. This argument is optional and the binary predicate less*<typename Container*::value_type***>* is the default value.

Remarks

The elements of class Type stipulated in the first template parameter of a queue object are synonymous with value_type and must match the type of element in the underlying container class Container stipulated by the second template parameter. The Type must be assignable, so that it is possible to copy objects of that type and to assign values to variables of that type.

The priority_queue orders the sequence it controls by calling a stored function object of class Traits. In general, the elements need be merely less than comparable to establish this order: so that, given any two elements, it may be determined either that they are equivalent (in the sense that neither is less than the other) or that one is less than the other. This results in an ordering between the nonequivalent elements. On a more technical note, the comparison function is a binary predicate that induces a strict weak ordering in the standard mathematical sense.

Suitable underlying container classes for priority_queue include deque Class and the default vector Class or any other sequence container that supports the operations of front, push_back, and pop_back and a random-access iterator. The underlying container class is encapsulated within the container adaptor, which exposes only the limited set of the sequence container member functions as a public interface.

Adding elements to and removing elements from a priority_queue both have logarithmic complexity. Accessing elements in a priority_queue has constant complexity.

There are three types of container adaptors defined by the STL: stack, queue, and priority_queue. Each restricts the functionality of some underlying container class to provide a precisely controlled interface to a standard data structure.

The stack class supports a last-in, first-out (LIFO) data structure. A good analogue to keep in mind would be a stack of plates. Elements (plates) may be inserted, inspected, or removed only from the top of the stack, which is the last element at the end of the base container. The restriction to accessing only the top element is the reason for using the stack class.
The queue class supports a first-in, first-out (FIFO) data structure. A good analogue to keep in mind would be people lining up for a bank teller. Elements (people) may be added to the back of the line and are removed from the front of the line. Both the front and the back of a line may be inspected. The restriction to accessing only the front and back elements in this way is the reason for using the queue class.
The priority_queue class orders its elements so that the largest element is always at the top position. It supports insertion of an element and the inspection and removal of the top element. A good analogue to keep in mind would be people lining up where they are arranged by age, height, or some other criterion.

Constructors

priority_queue

Constructs a priority_queue that is empty or that is a copy of a range of a base container object or of other priority_queue.

Typedefs

container_type	A type that provides the base container to be adapted by a priority_queue.
size_type	An unsigned integer type that can represent the number of elements in a priority_queue.
value_type	A type that represents the type of object stored as an element in a priority_queue.

Member Functions

empty	Tests if the priority_queue is empty.
pop	Removes the largest element of the priority_queue from the top position.
push	Adds an element to the priority queue based on the priority of the element from operator<.
size	Returns the number of elements in the priority_queue.
top	Returns a const reference to the largest element at the top of the priority_queue.

Requirements

Header: <queue>

Namespace: std