class ...
binomial heap

The template parameter T is the type to be managed by the container. The user can specify additional options and if no options are provided default options are used.

The container supports the following options:

- `boost::heap::stable<>`, defaults to `stable<false>`

- `boost::heap::compare<>`, defaults to `compare<std::less<T>` >

- `boost::heap::allocator<>`, defaults to `allocator<std::allocator<T>` >

- `boost::heap::constant_time_size<>`, defaults to `constant_time_size<true>`

- `boost::heap::stability_counter_type<>`, defaults to `stability_counter_type<boost::uintmax_t>`

T
implementation_defined::size_type
implementation_defined::difference_type
implementation_defined::value_compare
implementation_defined::allocator_type
implementation_defined::reference
implementation_defined::const_reference
implementation_defined::pointer
implementation_defined::const_pointer

Note: The iterator does not traverse the priority queue in order of the priorities.

implementation_defined::iterator
implementation_defined::const_iterator
implementation_defined::ordered_iterator
implementation_defined::handle_type
const bool
const bool
const bool
const bool
const bool
bool `void`

Effects: Returns true, if the priority queue contains no elements.

Complexity: Constant.

size_type `void`

Effects: Returns the number of elements contained in the priority queue.

Complexity: Constant, if configured with constant_time_size<true>, otherwise linear.

size_type `void`

Effects: Returns the maximum number of elements the priority queue can contain.

Complexity: Constant.

void `void`

Effects: Removes all elements from the priority queue.

Complexity: Linear.

allocator_type `void`

Effects: Returns allocator.

Complexity: Constant.

void ``binomial_heap` &`

Effects: Swaps two priority queues.

Complexity: Constant.

const_reference `void`

Effects: Returns a const_reference to the maximum element.

Complexity: Constant.

handle_type `value_type const &`

Effects: Adds a new element to the priority queue. Returns handle to element

Complexity: Logarithmic.

handle_type class... `Args &&...`

Effects: Adds a new element to the priority queue. The element is directly constructed in-place. Returns handle to element.

Complexity: Logarithmic.

void `void`

Effects: Removes the top element from the priority queue.

Complexity: Logarithmic.

void `handle_type` `const_reference`

Effects: Assigns `v` to the element handled by `handle` & updates the priority queue.

Complexity: Logarithmic.

void `handle_type`

Effects: Updates the heap after the element handled by `handle` has been changed.

Complexity: Logarithmic.

Note: If this is not called, after a handle has been updated, the behavior of the data structure is undefined!

void `handle_type` `const_reference`

Effects: Assigns `v` to the element handled by `handle` & updates the priority queue.

Complexity: Logarithmic.

Note: The new value is expected to be greater than the current one

void `handle_type`

Effects: Updates the heap after the element handled by `handle` has been changed.

Complexity: Logarithmic.

Note: If this is not called, after a handle has been updated, the behavior of the data structure is undefined!

void `handle_type` `const_reference`

Effects: Assigns `v` to the element handled by `handle` & updates the priority queue.

Complexity: Logarithmic.

Note: The new value is expected to be less than the current one

void `handle_type`

Effects: Updates the heap after the element handled by `handle` has been changed.

Complexity: Logarithmic.

Note: The new value is expected to be less than the current one. If this is not called, after a handle has been updated, the behavior of the data structure is undefined!

void ``binomial_heap` &`

Effects: Merge with priority queue rhs.

Complexity: Logarithmic.

iterator `void`

Effects: Returns an iterator to the first element contained in the priority queue.

Complexity: Constant.

iterator `void`

Effects: Returns an iterator to the end of the priority queue.

Complexity: Constant.

ordered_iterator `void`

Effects: Returns an ordered iterator to the first element contained in the priority queue.

Note: Ordered iterators traverse the priority queue in heap order.

ordered_iterator `void`

Effects: Returns an ordered iterator to the end of the priority queue.

Note: Ordered iterators traverse the priority queue in heap order.

void `handle_type`

Effects: Removes the element handled by `handle` from the `priority_queue`.

Complexity: Logarithmic.

value_compare const & `void`

Effect: Returns the value_compare object used by the priority queue

bool `HeapType const &`

Returns: Element-wise comparison of heap data structures

Requirement: the `value_compare` object of both heaps must match.

bool `HeapType const &`

Returns: Element-wise comparison of heap data structures

Requirement: the `value_compare` object of both heaps must match.

bool `HeapType const &`

Returns: Element-wise comparison of heap data structures

Requirement: the `value_compare` object of both heaps must match.

bool `HeapType const &`

Returns: Element-wise comparison of heap data structures

Requirement: the `value_compare` object of both heaps must match.

bool `HeapType const &` Equivalent comparison Returns: True, if both heap data structures are equivalent.

Requirement: the `value_compare` object of both heaps must match.

bool `HeapType const &` Equivalent comparison Returns: True, if both heap data structures are not equivalent.

Requirement: the `value_compare` object of both heaps must match.

value_compare const &
value_compare()

Effects: constructs an empty priority queue.

Complexity: Constant.

binomial_heap
const &

Effects: copy-constructs priority queue from rhs.

Complexity: Linear.

`binomial_heap` & ``binomial_heap` const &`

Effects: Assigns priority queue from rhs.

Complexity: Linear.

binomial_heap
&&

Effects: C++11-style move constructor.

Complexity: Constant.

Note: Only available, if BOOST_NO_CXX11_RVALUE_REFERENCES is not defined

`binomial_heap` & ``binomial_heap` &&`

Effects: C++11-style move assignment.

Complexity: Constant.

Note: Only available, if BOOST_NO_CXX11_RVALUE_REFERENCES is not defined

void
handle_type `iterator const &`
class ...
d-ary heap class

This class implements an immutable priority queue. Internally, the d-ary heap is represented as dynamically sized array (std::vector), that directly stores the values.

The template parameter T is the type to be managed by the container. The user can specify additional options and if no options are provided default options are used.

The container supports the following options:

- `boost::heap::arity<>`, required

- `boost::heap::compare<>`, defaults to `compare<std::less<T>` >

- `boost::heap::stable<>`, defaults to `stable<false>`

- `boost::heap::stability_counter_type<>`, defaults to `stability_counter_type<boost::uintmax_t>`

- `boost::heap::allocator<>`, defaults to `allocator<std::allocator<T>` >

- `boost::heap::mutable_<>`, defaults to `mutable_<false>`

T
implementation_defined::size_type
implementation_defined::difference_type
implementation_defined::value_compare
implementation_defined::allocator_type
implementation_defined::reference
implementation_defined::const_reference
implementation_defined::pointer
implementation_defined::const_pointer

Note: The iterator does not traverse the priority queue in order of the priorities.

implementation_defined::iterator
implementation_defined::const_iterator
implementation_defined::ordered_iterator
implementation_defined::handle_type
const bool
const bool
const bool
const bool
const bool
bool `void`

Effects: Returns true, if the priority queue contains no elements.

Complexity: Constant.

size_type `void`

Effects: Returns the number of elements contained in the priority queue.

Complexity: Constant.

size_type `void`

Effects: Returns the maximum number of elements the priority queue can contain.

Complexity: Constant.

void `void`

Effects: Removes all elements from the priority queue.

Complexity: Linear.

allocator_type `void`

Effects: Returns allocator.

Complexity: Constant.

value_type const & `void`

Effects: Returns a const_reference to the maximum element.

Complexity: Constant.

boost::conditional< is_mutable, handle_type, void >::type `value_type const &`

Effects: Adds a new element to the priority queue.

Complexity: Logarithmic (amortized). Linear (worst case).

boost::conditional< is_mutable, handle_type, void >::type class... `Args &&...`

Effects: Adds a new element to the priority queue. The element is directly constructed in-place.

Complexity: Logarithmic (amortized). Linear (worst case).

bool `HeapType const &`

Returns: Element-wise comparison of heap data structures

Requirement: the `value_compare` object of both heaps must match.

bool `HeapType const &`

Returns: Element-wise comparison of heap data structures

Requirement: the `value_compare` object of both heaps must match.

bool `HeapType const &`

Returns: Element-wise comparison of heap data structures

Requirement: the `value_compare` object of both heaps must match.

bool `HeapType const &`

Returns: Element-wise comparison of heap data structures

Requirement: the `value_compare` object of both heaps must match.

bool `HeapType const &` Equivalent comparison Returns: True, if both heap data structures are equivalent.

Requirement: the `value_compare` object of both heaps must match.

bool `HeapType const &` Equivalent comparison Returns: True, if both heap data structures are not equivalent.

Requirement: the `value_compare` object of both heaps must match.

void `handle_type` `const_reference`

Effects: Assigns `v` to the element handled by `handle` & updates the priority queue.

Complexity: Logarithmic.

Requirement: data structure must be configured as mutable

void `handle_type`

Effects: Updates the heap after the element handled by `handle` has been changed.

Complexity: Logarithmic.

Note: If this is not called, after a handle has been updated, the behavior of the data structure is undefined!

Requirement: data structure must be configured as mutable

void `handle_type` `const_reference`

Effects: Assigns `v` to the element handled by `handle` & updates the priority queue.

Complexity: Logarithmic.

Note: The new value is expected to be greater than the current one

Requirement: data structure must be configured as mutable

void `handle_type`

Effects: Updates the heap after the element handled by `handle` has been changed.

Complexity: Logarithmic.

Note: The new value is expected to be greater than the current one. If this is not called, after a handle has been updated, the behavior of the data structure is undefined!

Requirement: data structure must be configured as mutable

void `handle_type` `const_reference`

Effects: Assigns `v` to the element handled by `handle` & updates the priority queue.

Complexity: Logarithmic.

Note: The new value is expected to be less than the current one

Requirement: data structure must be configured as mutable

void `handle_type`

Effects: Updates the heap after the element handled by `handle` has been changed.

Complexity: Logarithmic.

Note: The new value is expected to be less than the current one. If this is not called, after a handle has been updated, the behavior of the data structure is undefined!

Requirement: data structure must be configured as mutable

void `handle_type`

Effects: Removes the element handled by `handle` from the `priority_queue`.

Complexity: Logarithmic.

Requirement: data structure must be configured as mutable

void `void`

Effects: Removes the top element from the priority queue.

Complexity: Logarithmic (amortized). Linear (worst case).

void ``d_ary_heap` &`

Effects: Swaps two priority queues.

Complexity: Constant.

const_iterator `void`

Effects: Returns an iterator to the first element contained in the priority queue.

Complexity: Constant.

iterator `void`

Effects: Returns an iterator to the first element contained in the priority queue.

Complexity: Constant.

iterator `void`

Effects: Returns an iterator to the end of the priority queue.

Complexity: Constant.

const_iterator `void`

Effects: Returns an iterator to the end of the priority queue.

Complexity: Constant.

ordered_iterator `void`

Effects: Returns an ordered iterator to the first element contained in the priority queue.

Note: Ordered iterators traverse the priority queue in heap order.

ordered_iterator `void`

Effects: Returns an ordered iterator to the end of the priority queue.

Note: Ordered iterators traverse the priority queue in heap order.

void `size_type`

Effects: Reserves memory for element_count elements

Complexity: Linear.

Node: Invalidates iterators

value_compare const & `void`

Effect: Returns the value_compare object used by the priority queue

value_compare const &
value_compare()

Effects: constructs an empty priority queue.

Complexity: Constant.

d_ary_heap
const &

Effects: copy-constructs priority queue from rhs.

Complexity: Linear.

d_ary_heap
&&

Effects: C++11-style move constructor.

Complexity: Constant.

Note: Only available, if BOOST_NO_CXX11_RVALUE_REFERENCES is not defined

`d_ary_heap` & ``d_ary_heap` &&`

Effects: C++11-style move assignment.

Complexity: Constant.

Note: Only available, if BOOST_NO_CXX11_RVALUE_REFERENCES is not defined

`d_ary_heap` & ``d_ary_heap` const &`

Effects: Assigns priority queue from rhs.

Complexity: Linear.

handle_type `iterator const &`

Effects: Casts an iterator to a node handle.

Complexity: Constant.

Requirement: data structure must be configured as mutable

class ...
fibonacci heap

The template parameter T is the type to be managed by the container. The user can specify additional options and if no options are provided default options are used.

The container supports the following options:

- `boost::heap::stable<>`, defaults to `stable<false>`

- `boost::heap::compare<>`, defaults to `compare<std::less<T>` >

- `boost::heap::allocator<>`, defaults to `allocator<std::allocator<T>` >

- `boost::heap::constant_time_size<>`, defaults to `constant_time_size<true>`

- `boost::heap::stability_counter_type<>`, defaults to `stability_counter_type<boost::uintmax_t>`

T
implementation_defined::size_type
implementation_defined::difference_type
implementation_defined::value_compare
implementation_defined::allocator_type
implementation_defined::reference
implementation_defined::const_reference
implementation_defined::pointer
implementation_defined::const_pointer

Note: The iterator does not traverse the priority queue in order of the priorities.

implementation_defined::iterator
implementation_defined::const_iterator
implementation_defined::ordered_iterator
implementation_defined::handle_type
const bool
const bool
const bool
const bool
const bool
bool `void`

Effects: Returns true, if the priority queue contains no elements.

Complexity: Constant.

size_type `void`

Effects: Returns the number of elements contained in the priority queue.

Complexity: Constant.

size_type `void`

Effects: Returns the maximum number of elements the priority queue can contain.

Complexity: Constant.

void `void`

Effects: Removes all elements from the priority queue.

Complexity: Linear.

allocator_type `void`

Effects: Returns allocator.

Complexity: Constant.

void ``fibonacci_heap` &`

Effects: Swaps two priority queues.

Complexity: Constant.

value_type const & `void`

Effects: Returns a const_reference to the maximum element.

Complexity: Constant.

handle_type `value_type const &`

Effects: Adds a new element to the priority queue. Returns handle to element

Complexity: Constant.

Note: Does not invalidate iterators.

handle_type class... `Args &&...`

Effects: Adds a new element to the priority queue. The element is directly constructed in-place. Returns handle to element.

Complexity: Constant.

Note: Does not invalidate iterators.

void `void`

Effects: Removes the top element from the priority queue.

Complexity: Logarithmic (amortized). Linear (worst case).

void `handle_type` `const_reference`

Effects: Assigns `v` to the element handled by `handle` & updates the priority queue.

Complexity: Logarithmic if current value < v, Constant otherwise.

void `handle_type` `const_reference`

Effects: Assigns `v` to the element handled by `handle` & updates the priority queue.

Complexity: Logarithmic if current value < v, Constant otherwise.

Rationale: The lazy update function is a modification of the traditional update, that just invalidates the iterator to the object referred to by the handle.

void `handle_type`

Effects: Updates the heap after the element handled by `handle` has been changed.

Complexity: Logarithmic.

Note: If this is not called, after a handle has been updated, the behavior of the data structure is undefined!

void `handle_type` (handle_type handle)

Effects: Assigns `v` to the element handled by `handle` & updates the priority queue.

Complexity: Logarithmic if current value < v, Constant otherwise. (handle_type handle)

Rationale: The lazy update function is a modification of the traditional update, that just invalidates the iterator to the object referred to by the handle.

void `handle_type` `const_reference`

Effects: Assigns `v` to the element handled by `handle` & updates the priority queue.

Complexity: Constant.

Note: The new value is expected to be greater than the current one

void `handle_type`

Effects: Updates the heap after the element handled by `handle` has been changed.

Complexity: Constant.

Note: If this is not called, after a handle has been updated, the behavior of the data structure is undefined!

void `handle_type` `const_reference`

Effects: Assigns `v` to the element handled by `handle` & updates the priority queue.

Complexity: Logarithmic.

Note: The new value is expected to be less than the current one

void `handle_type`

Effects: Updates the heap after the element handled by `handle` has been changed.

Complexity: Logarithmic.

Note: The new value is expected to be less than the current one. If this is not called, after a handle has been updated, the behavior of the data structure is undefined!

void `handle_type const &`

Effects: Removes the element handled by `handle` from the `priority_queue`.

Complexity: Logarithmic.

iterator `void`

Effects: Returns an iterator to the first element contained in the priority queue.

Complexity: Constant.

iterator `void`

Effects: Returns an iterator to the end of the priority queue.

Complexity: Constant.

ordered_iterator `void`

Effects: Returns an ordered iterator to the first element contained in the priority queue.

Note: Ordered iterators traverse the priority queue in heap order.

ordered_iterator `void`

Effects: Returns an ordered iterator to the end of the priority queue.

Note: Ordered iterators traverse the priority queue in heap order.

void ``fibonacci_heap` &`

Effects: Merge with priority queue rhs.

Complexity: Constant.

value_compare const & `void`

Effect: Returns the value_compare object used by the priority queue

bool `HeapType const &`

Returns: Element-wise comparison of heap data structures

Requirement: the `value_compare` object of both heaps must match.

bool `HeapType const &`

Returns: Element-wise comparison of heap data structures

Requirement: the `value_compare` object of both heaps must match.

bool `HeapType const &`

Returns: Element-wise comparison of heap data structures

Requirement: the `value_compare` object of both heaps must match.

bool `HeapType const &`

Returns: Element-wise comparison of heap data structures

Requirement: the `value_compare` object of both heaps must match.

bool `HeapType const &` Equivalent comparison Returns: True, if both heap data structures are equivalent.

Requirement: the `value_compare` object of both heaps must match.

bool `HeapType const &` Equivalent comparison Returns: True, if both heap data structures are not equivalent.

Requirement: the `value_compare` object of both heaps must match.

value_compare const &
value_compare()

Effects: constructs an empty priority queue.

Complexity: Constant.

fibonacci_heap
const &

Effects: copy-constructs priority queue from rhs.

Complexity: Linear.

fibonacci_heap
&&

Effects: C++11-style move constructor.

Complexity: Constant.

Note: Only available, if BOOST_NO_CXX11_RVALUE_REFERENCES is not defined

`fibonacci_heap` & ``fibonacci_heap` &&`

Effects: C++11-style move assignment.

Complexity: Constant.

Note: Only available, if BOOST_NO_CXX11_RVALUE_REFERENCES is not defined

`fibonacci_heap` & ``fibonacci_heap` const &`

Effects: Assigns priority queue from rhs.

Complexity: Linear.

void
handle_type `iterator const &`
boost::heap::PriorityQueue< C >
MergablePriorityQueue
PriorityQueue
C::iterator
C::const_iterator
C::allocator_type
C::value_compare
C::value_type
C::const_reference
boost::heap::PriorityQueue< C >
C::handle_type
C::iterator
C::const_iterator
C::allocator_type
C::value_compare
C::value_type
C::const_reference
C
bool
bool
MutablePriorityQueue
PriorityQueue
boost::ForwardContainer< C >
C::iterator
C::const_iterator
C::allocator_type
C::value_compare
C::value_type
C::const_reference
PriorityQueue
void `Heap1 &` `Heap2 &`

merge rhs into lhs

Effect: lhs contains all elements that have been part of rhs, rhs is empty.

class ...
pairing heap

Pairing heaps are self-adjusting binary heaps. Although design and implementation are rather simple, the complexity analysis is yet unsolved. For details, consult:

Pettie, Seth (2005), "Towards a final analysis of pairing heaps", Proc. 46th Annual IEEE Symposium on Foundations of Computer Science, pp. 174-183

The template parameter T is the type to be managed by the container. The user can specify additional options and if no options are provided default options are used.

The container supports the following options:

- `boost::heap::compare<>`, defaults to `compare<std::less<T>` >

- `boost::heap::stable<>`, defaults to `stable<false>`

- `boost::heap::stability_counter_type<>`, defaults to `stability_counter_type<boost::uintmax_t>`

- `boost::heap::allocator<>`, defaults to `allocator<std::allocator<T>` >

- `boost::heap::constant_time_size<>`, defaults to `constant_time_size<true>`

T
implementation_defined::size_type
implementation_defined::difference_type
implementation_defined::value_compare
implementation_defined::allocator_type
implementation_defined::reference
implementation_defined::const_reference
implementation_defined::pointer
implementation_defined::const_pointer

Note: The iterator does not traverse the priority queue in order of the priorities.

implementation_defined::iterator
implementation_defined::const_iterator
implementation_defined::ordered_iterator
implementation_defined::handle_type
const bool
const bool
const bool
const bool
const bool
bool `void`

Effects: Returns true, if the priority queue contains no elements.

Complexity: Constant.

size_type `void`

Effects: Returns the number of elements contained in the priority queue.

Complexity: Constant, if configured with constant_time_size<true>, otherwise linear.

size_type `void`

Effects: Returns the maximum number of elements the priority queue can contain.

Complexity: Constant.

void `void`

Effects: Removes all elements from the priority queue.

Complexity: Linear.

allocator_type `void`

Effects: Returns allocator.

Complexity: Constant.

void ``pairing_heap` &`

Effects: Swaps two priority queues.

Complexity: Constant.

const_reference `void`

Effects: Returns a const_reference to the maximum element.

Complexity: Constant.

handle_type `value_type const &`

Effects: Adds a new element to the priority queue. Returns handle to elementComplexity: 2**2*log(log(N)) (amortized).

handle_type class... `Args &&...`

Effects: Adds a new element to the priority queue. The element is directly constructed in-place. Returns handle to element.Complexity: 2**2*log(log(N)) (amortized).

void `void`

Effects: Removes the top element from the priority queue.

Complexity: Logarithmic (amortized).

void `handle_type` `const_reference`

Effects: Assigns `v` to the element handled by `handle` & updates the priority queue.Complexity: 2**2*log(log(N)) (amortized).

void `handle_type`

Effects: Updates the heap after the element handled by `handle` has been changed.Complexity: 2**2*log(log(N)) (amortized).

Note: If this is not called, after a handle has been updated, the behavior of the data structure is undefined!

void `handle_type` `const_reference`

Effects: Assigns `v` to the element handled by `handle` & updates the priority queue.Complexity: 2**2*log(log(N)) (amortized).

Note: The new value is expected to be greater than the current one

void `handle_type`

Effects: Updates the heap after the element handled by `handle` has been changed.Complexity: 2**2*log(log(N)) (amortized).

Note: If this is not called, after a handle has been updated, the behavior of the data structure is undefined!

void `handle_type` `const_reference`

Effects: Assigns `v` to the element handled by `handle` & updates the priority queue.Complexity: 2**2*log(log(N)) (amortized).

Note: The new value is expected to be less than the current one

void `handle_type`

Effects: Updates the heap after the element handled by `handle` has been changed.Complexity: 2**2*log(log(N)) (amortized).

Note: The new value is expected to be less than the current one. If this is not called, after a handle has been updated, the behavior of the data structure is undefined!

void `handle_type`

Effects: Removes the element handled by `handle` from the `priority_queue`.Complexity: 2**2*log(log(N)) (amortized).

iterator `void`

Effects: Returns an iterator to the first element contained in the priority queue.

Complexity: Constant.

iterator `void`

Effects: Returns an iterator to the end of the priority queue.

Complexity: Constant.

ordered_iterator `void`

Effects: Returns an ordered iterator to the first element contained in the priority queue.

Note: Ordered iterators traverse the priority queue in heap order.

ordered_iterator `void`

Effects: Returns an ordered iterator to the first element contained in the priority queue.

Note: Ordered iterators traverse the priority queue in heap order.

void ``pairing_heap` &`

Effects: Merge all elements from rhs into thisComplexity: 2**2*log(log(N)) (amortized).

value_compare const & `void`

Effect: Returns the value_compare object used by the priority queue

bool `HeapType const &`

Returns: Element-wise comparison of heap data structures

Requirement: the `value_compare` object of both heaps must match.

bool `HeapType const &`

Returns: Element-wise comparison of heap data structures

Requirement: the `value_compare` object of both heaps must match.

bool `HeapType const &`

Returns: Element-wise comparison of heap data structures

Requirement: the `value_compare` object of both heaps must match.

bool `HeapType const &`

Returns: Element-wise comparison of heap data structures

Requirement: the `value_compare` object of both heaps must match.

bool `HeapType const &` Equivalent comparison Returns: True, if both heap data structures are equivalent.

Requirement: the `value_compare` object of both heaps must match.

bool `HeapType const &` Equivalent comparison Returns: True, if both heap data structures are not equivalent.

Requirement: the `value_compare` object of both heaps must match.

value_compare const &
value_compare()

Effects: constructs an empty priority queue.

Complexity: Constant.

pairing_heap
const &

Effects: copy-constructs priority queue from rhs.

Complexity: Linear.

pairing_heap
&&

Effects: C++11-style move constructor.

Complexity: Constant.

Note: Only available, if BOOST_NO_CXX11_RVALUE_REFERENCES is not defined

`pairing_heap` & ``pairing_heap` &&`

Effects: C++11-style move assignment.

Complexity: Constant.

Note: Only available, if BOOST_NO_CXX11_RVALUE_REFERENCES is not defined

`pairing_heap` & ``pairing_heap` const &`

Effects: Assigns priority queue from rhs.

Complexity: Linear.

void
handle_type `iterator const &`
Specifies allocator for the internal memory management.
unsigned int
Specify arity.

Specifies the arity of a D-ary heap

Specifies the predicate for the heap order.
bool
Configures complexity of `size()`

Specifies, whether size() should have linear or constant complexity.

bool
Configure heap as mutable.

Certain heaps need to be configured specifically do be mutable.

Specifies the type for stability counter.
bool
Configure a heap as stable.

A priority queue is stable, if elements with the same priority are popped from the heap, in the same order as they are inserted.

bool
Store parent pointer in heap node.

Maintaining a parent pointer adds some maintenance and size overhead, but iterating a heap is more efficient.

class ...
priority queue, based on stl heap functions

The `priority_queue` class is a wrapper for the stl heap functions. The template parameter T is the type to be managed by the container. The user can specify additional options and if no options are provided default options are used.

The container supports the following options:

- `boost::heap::compare<>`, defaults to `compare<std::less<T>` >

- `boost::heap::stable<>`, defaults to `stable<false>`

- `boost::heap::stability_counter_type<>`, defaults to `stability_counter_type<boost::uintmax_t>`

- `boost::heap::allocator<>`, defaults to `allocator<std::allocator<T>` >

T
implementation_defined::size_type
implementation_defined::difference_type
implementation_defined::value_compare
implementation_defined::allocator_type
implementation_defined::reference
implementation_defined::const_reference
implementation_defined::pointer
implementation_defined::const_pointer

Note: The iterator does not traverse the priority queue in order of the priorities.

implementation_defined::iterator
implementation_defined::const_iterator
const bool
const bool
const bool
const bool
const bool
bool `void`

Effects: Returns true, if the priority queue contains no elements.

Complexity: Constant.

size_type `void`

Effects: Returns the number of elements contained in the priority queue.

Complexity: Constant.

size_type `void`

Effects: Returns the maximum number of elements the priority queue can contain.

Complexity: Constant.

void `void`

Effects: Removes all elements from the priority queue.

Complexity: Linear.

allocator_type `void`

Effects: Returns allocator.

Complexity: Constant.

const_reference `void`

Effects: Returns a const_reference to the maximum element.

Complexity: Constant.

void `value_type const &`

Effects: Adds a new element to the priority queue.

Complexity: Logarithmic (amortized). Linear (worst case).

void class... `Args &&...`

Effects: Adds a new element to the priority queue. The element is directly constructed in-place.

Complexity: Logarithmic (amortized). Linear (worst case).

void `void`

Effects: Removes the top element from the priority queue.

Complexity: Logarithmic (amortized). Linear (worst case).

void ``priority_queue` &`

Effects: Swaps two priority queues.

Complexity: Constant.

iterator `void`

Effects: Returns an iterator to the first element contained in the priority queue.

Complexity: Constant.

iterator `void`

Effects: Returns an iterator to the end of the priority queue.

Complexity: Constant.

void `size_type`

Effects: Reserves memory for element_count elements

Complexity: Linear.

Node: Invalidates iterators

value_compare const & `void`

Effect: Returns the value_compare object used by the priority queue

bool `HeapType const &`

Returns: Element-wise comparison of heap data structures

Requirement: the `value_compare` object of both heaps must match.

bool `HeapType const &`

Returns: Element-wise comparison of heap data structures

Requirement: the `value_compare` object of both heaps must match.

bool `HeapType const &`

Returns: Element-wise comparison of heap data structures

Requirement: the `value_compare` object of both heaps must match.

bool `HeapType const &`

Returns: Element-wise comparison of heap data structures

Requirement: the `value_compare` object of both heaps must match.

bool `HeapType const &` Equivalent comparison Returns: True, if both heap data structures are equivalent.

Requirement: the `value_compare` object of both heaps must match.

bool `HeapType const &` Equivalent comparison Returns: True, if both heap data structures are not equivalent.

Requirement: the `value_compare` object of both heaps must match.

value_compare const &
value_compare()

Effects: constructs an empty priority queue.

Complexity: Constant.

priority_queue
const &

Effects: copy-constructs priority queue from rhs.

Complexity: Linear.

priority_queue
&&

Effects: C++11-style move constructor.

Complexity: Constant.

Note: Only available, if BOOST_NO_CXX11_RVALUE_REFERENCES is not defined

`priority_queue` & ``priority_queue` &&`

Effects: C++11-style move assignment.

Complexity: Constant.

Note: Only available, if BOOST_NO_CXX11_RVALUE_REFERENCES is not defined

`priority_queue` & ``priority_queue` const &`

Effects: Assigns priority queue from rhs.

Complexity: Linear.

class ...
skew heap

The template parameter T is the type to be managed by the container. The user can specify additional options and if no options are provided default options are used.

The container supports the following options:

- `boost::heap::compare<>`, defaults to `compare<std::less<T>` >

- `boost::heap::stable<>`, defaults to `stable<false>`

- `boost::heap::stability_counter_type<>`, defaults to `stability_counter_type<boost::uintmax_t>`

- `boost::heap::allocator<>`, defaults to `allocator<std::allocator<T>` >

- `boost::heap::constant_time_size<>`, defaults to `constant_time_size<true>`

- `boost::heap::store_parent_pointer<>`, defaults to `store_parent_pointer<true>`. Maintaining a parent pointer adds some maintenance and size overhead, but iterating a heap is more efficient.

- `boost::heap::mutable<>`, defaults to `mutable<false>`.

boost::parameter::void_
boost::parameter::void_
boost::parameter::void_
boost::parameter::void_
boost::parameter::void_
boost::parameter::void_
boost::parameter::void_
T
base_maker::compare_argument
base_maker::allocator_type
base_maker::node_type
boost::allocator_pointer< allocator_type >::type
boost::allocator_const_pointer< allocator_type >::type
unspecified
boost::array< node_pointer, 2 >
child_list_type::iterator
unspecified
iterator
unspecified
unspecified
unspecified
boost::parameter::void_
boost::parameter::void_
boost::parameter::void_
boost::parameter::void_
boost::parameter::void_
boost::parameter::void_
boost::parameter::void_
handle_type ``skew_heap` *` `const_reference`
handle_type class... ``skew_heap` *` `Args &&...`
boost::parameter::void_
boost::parameter::void_
boost::parameter::void_
boost::parameter::void_
boost::parameter::void_
boost::parameter::void_
boost::parameter::void_
void ``skew_heap` *` `const_reference`
void class... ``skew_heap` *` `Args &&...`
T
implementation_defined::size_type
implementation_defined::difference_type
implementation_defined::value_compare
implementation_defined::allocator_type
implementation_defined::reference
implementation_defined::const_reference
implementation_defined::pointer
implementation_defined::const_pointer

Note: The iterator does not traverse the priority queue in order of the priorities.

implementation_defined::iterator
implementation_defined::const_iterator
implementation_defined::ordered_iterator
boost::conditional< is_mutable, typename implementation_defined::handle_type, void * >::type
const bool
const bool
const bool
const bool
const bool
const bool
boost::conditional< is_mutable, handle_type, void >::type `value_type const &`

Effects: Adds a new element to the priority queue.

Complexity: Logarithmic (amortized).

boost::conditional< is_mutable, handle_type, void >::type typename... `Args &&...`

Effects: Adds a new element to the priority queue. The element is directly constructed in-place.

Complexity: Logarithmic (amortized).

bool `void`

Effects: Returns true, if the priority queue contains no elements.

Complexity: Constant.

size_type `void`

Effects: Returns the number of elements contained in the priority queue.

Complexity: Constant, if configured with constant_time_size<true>, otherwise linear.

size_type `void`

Effects: Returns the maximum number of elements the priority queue can contain.

Complexity: Constant.

void `void`

Effects: Removes all elements from the priority queue.

Complexity: Linear.

allocator_type `void`

Effects: Returns allocator.

Complexity: Constant.

void ``skew_heap` &`

Effects: Swaps two priority queues.

Complexity: Constant.

const_reference `void`

Effects: Returns a const_reference to the maximum element.

Complexity: Constant.

void `void`

Effects: Removes the top element from the priority queue.

Complexity: Logarithmic (amortized).

iterator `void`

Effects: Returns an iterator to the first element contained in the priority queue.

Complexity: Constant.

iterator `void`

Effects: Returns an iterator to the end of the priority queue.

Complexity: Constant.

ordered_iterator `void`

Effects: Returns an ordered iterator to the first element contained in the priority queue.

Note: Ordered iterators traverse the priority queue in heap order.

ordered_iterator `void`

Effects: Returns an ordered iterator to the first element contained in the priority queue.

Note: Ordered iterators traverse the priority queue in heap order.

void ``skew_heap` &`

Effects: Merge all elements from rhs into this

Complexity: Logarithmic (amortized).

value_compare const & `void`

Effect: Returns the value_compare object used by the priority queue

bool `HeapType const &`

Returns: Element-wise comparison of heap data structures

Requirement: the `value_compare` object of both heaps must match.

bool `HeapType const &`

Returns: Element-wise comparison of heap data structures

Requirement: the `value_compare` object of both heaps must match.

bool `HeapType const &`

Returns: Element-wise comparison of heap data structures

Requirement: the `value_compare` object of both heaps must match.

bool `HeapType const &`

Returns: Element-wise comparison of heap data structures

Requirement: the `value_compare` object of both heaps must match.

bool `HeapType const &` Equivalent comparison Returns: True, if both heap data structures are equivalent.

Requirement: the `value_compare` object of both heaps must match.

bool `HeapType const &` Equivalent comparison Returns: True, if both heap data structures are not equivalent.

Requirement: the `value_compare` object of both heaps must match.

void `handle_type`

Effects: Removes the element handled by `handle` from the `priority_queue`.

Complexity: Logarithmic (amortized).

void `handle_type` `const_reference`

Effects: Assigns `v` to the element handled by `handle` & updates the priority queue.

Complexity: Logarithmic (amortized).

void `handle_type`

Effects: Updates the heap after the element handled by `handle` has been changed.

Complexity: Logarithmic (amortized).

Note: If this is not called, after a handle has been updated, the behavior of the data structure is undefined!

void `handle_type` `const_reference`

Effects: Assigns `v` to the element handled by `handle` & updates the priority queue.

Complexity: Logarithmic (amortized).

Note: The new value is expected to be greater than the current one

void `handle_type`

Effects: Updates the heap after the element handled by `handle` has been changed.

Complexity: Logarithmic (amortized).

Note: If this is not called, after a handle has been updated, the behavior of the data structure is undefined!

void `handle_type` `const_reference`

Effects: Assigns `v` to the element handled by `handle` & updates the priority queue.

Complexity: Logarithmic (amortized).

Note: The new value is expected to be less than the current one

void `handle_type`

Effects: Updates the heap after the element handled by `handle` has been changed.

Complexity: Logarithmic (amortized).

Note: The new value is expected to be less than the current one. If this is not called, after a handle has been updated, the behavior of the data structure is undefined!

value_compare const &
value_compare()

Effects: constructs an empty priority queue.

Complexity: Constant.

skew_heap
const &

Effects: copy-constructs priority queue from rhs.

Complexity: Linear.

`skew_heap` & ``skew_heap` const &`

Effects: Assigns priority queue from rhs.

Complexity: Linear.

skew_heap
&&

Effects: C++11-style move constructor.

Complexity: Constant.

Note: Only available, if BOOST_NO_CXX11_RVALUE_REFERENCES is not defined

`skew_heap` & ``skew_heap` &&`

Effects: C++11-style move assignment.

Complexity: Constant.

Note: Only available, if BOOST_NO_CXX11_RVALUE_REFERENCES is not defined

void
handle_type `iterator const &`

Effects: Casts an iterator to a node handle.

Complexity: Constant.

Requirement: data structure must be configured as mutable

node_pointer `const_reference`
node_pointer class... `Args &&...`
void `node_pointer`
void ``skew_heap` const &`
void `node_pointer`
node_pointer `node_pointer` `node_pointer` `node_pointer`
node_pointer `node_pointer`
node_pointer `node_pointer` `node_pointer` `node_pointer`
void `void`