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

boolvoidEffects: Returns true, if the priority queue contains no elements.Complexity: Constant. size_typevoidEffects: Returns the number of elements contained in the priority queue.Complexity: Constant, if configured with constant_time_size<true>, otherwise linear. size_typevoidEffects: Returns the maximum number of elements the priority queue can contain.Complexity: Constant. voidvoidEffects: Removes all elements from the priority queue.Complexity: Linear. allocator_typevoidEffects: Returns allocator.Complexity: Constant. voidbinomial_heap &Effects: Swaps two priority queues.Complexity: Constant. const_referencevoidEffects: Returns a const_reference to the maximum element.Complexity: Constant. handle_typevalue_type const &Effects: Adds a new element to the priority queue. Returns handle to elementComplexity: Logarithmic. handle_typeArgs &&...Effects: Adds a new element to the priority queue. The element is directly constructed in-place. Returns handle to element.Complexity: Logarithmic. voidvoidEffects: Removes the top element from the priority queue.Complexity: Logarithmic. voidhandle_typeconst_referenceEffects: Assigns v to the element handled by handle & updates the priority queue.Complexity: Logarithmic. voidhandle_typeEffects: 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! voidhandle_typeconst_referenceEffects: 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 voidhandle_typeEffects: 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! voidhandle_typeconst_referenceEffects: 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 voidhandle_typeEffects: 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! voidbinomial_heap &Effects: Merge with priority queue rhs.Complexity: Logarithmic. iteratorvoidEffects: Returns an iterator to the first element contained in the priority queue.Complexity: Constant. iteratorvoidEffects: Returns an iterator to the end of the priority queue.Complexity: Constant. ordered_iteratorvoidEffects: Returns an ordered iterator to the first element contained in the priority queue.Note: Ordered iterators traverse the priority queue in heap order. ordered_iteratorvoidEffects: Returns an ordered iterator to the end of the priority queue.Note: Ordered iterators traverse the priority queue in heap order. voidhandle_typeEffects: Removes the element handled by handle from the priority_queue.Complexity: Logarithmic. value_compare const &voidEffect: Returns the value_compare object used by the priority queue boolHeapType const &Returns: Element-wise comparison of heap data structuresRequirement: the value_compare object of both heaps must match. boolHeapType const &Returns: Element-wise comparison of heap data structuresRequirement: the value_compare object of both heaps must match. boolHeapType const &Returns: Element-wise comparison of heap data structuresRequirement: the value_compare object of both heaps must match. boolHeapType const &Returns: Element-wise comparison of heap data structuresRequirement: the value_compare object of both heaps must match. boolHeapType const &Equivalent comparison Returns: True, if both heap data structures are equivalent. Requirement: the value_compare object of both heaps must match. boolHeapType 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_typeiterator const &

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

boolvoidEffects: Returns true, if the priority queue contains no elements.Complexity: Constant. size_typevoidEffects: Returns the number of elements contained in the priority queue.Complexity: Constant. size_typevoidEffects: Returns the maximum number of elements the priority queue can contain.Complexity: Constant. voidvoidEffects: Removes all elements from the priority queue.Complexity: Linear. allocator_typevoidEffects: Returns allocator.Complexity: Constant. value_type const &voidEffects: Returns a const_reference to the maximum element.Complexity: Constant. boost::conditional< is_mutable, handle_type, void >::typevalue_type const &Effects: Adds a new element to the priority queue.Complexity: Logarithmic (amortized). Linear (worst case). boost::conditional< is_mutable, handle_type, void >::typeArgs &&...Effects: Adds a new element to the priority queue. The element is directly constructed in-place.Complexity: Logarithmic (amortized). Linear (worst case). boolHeapType const &Returns: Element-wise comparison of heap data structuresRequirement: the value_compare object of both heaps must match. boolHeapType const &Returns: Element-wise comparison of heap data structuresRequirement: the value_compare object of both heaps must match. boolHeapType const &Returns: Element-wise comparison of heap data structuresRequirement: the value_compare object of both heaps must match. boolHeapType const &Returns: Element-wise comparison of heap data structuresRequirement: the value_compare object of both heaps must match. boolHeapType const &Equivalent comparison Returns: True, if both heap data structures are equivalent. Requirement: the value_compare object of both heaps must match. boolHeapType const &Equivalent comparison Returns: True, if both heap data structures are not equivalent. Requirement: the value_compare object of both heaps must match. voidhandle_typeconst_referenceEffects: Assigns v to the element handled by handle & updates the priority queue.Complexity: Logarithmic.Requirement: data structure must be configured as mutable voidhandle_typeEffects: 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 voidhandle_typeconst_referenceEffects: 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 oneRequirement: data structure must be configured as mutable voidhandle_typeEffects: 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 voidhandle_typeconst_referenceEffects: 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 oneRequirement: data structure must be configured as mutable voidhandle_typeEffects: 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 voidhandle_typeEffects: Removes the element handled by handle from the priority_queue.Complexity: Logarithmic.Requirement: data structure must be configured as mutable voidvoidEffects: Removes the top element from the priority queue.Complexity: Logarithmic (amortized). Linear (worst case). voidd_ary_heap &Effects: Swaps two priority queues.Complexity: Constant. const_iteratorvoidEffects: Returns an iterator to the first element contained in the priority queue.Complexity: Constant. iteratorvoidEffects: Returns an iterator to the first element contained in the priority queue.Complexity: Constant. iteratorvoidEffects: Returns an iterator to the end of the priority queue.Complexity: Constant. const_iteratorvoidEffects: Returns an iterator to the end of the priority queue.Complexity: Constant. ordered_iteratorvoidEffects: Returns an ordered iterator to the first element contained in the priority queue.Note: Ordered iterators traverse the priority queue in heap order. ordered_iteratorvoidEffects: Returns an ordered iterator to the end of the priority queue.Note: Ordered iterators traverse the priority queue in heap order. voidsize_typeEffects: Reserves memory for element_count elementsComplexity: Linear.Node: Invalidates iterators value_compare const &voidEffect: 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_typeiterator const &Effects: Casts an iterator to a node handle.Complexity: Constant.Requirement: data structure must be configured as mutable

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

boolvoidEffects: Returns true, if the priority queue contains no elements.Complexity: Constant. size_typevoidEffects: Returns the number of elements contained in the priority queue.Complexity: Constant. size_typevoidEffects: Returns the maximum number of elements the priority queue can contain.Complexity: Constant. voidvoidEffects: Removes all elements from the priority queue.Complexity: Linear. allocator_typevoidEffects: Returns allocator.Complexity: Constant. voidfibonacci_heap &Effects: Swaps two priority queues.Complexity: Constant. value_type const &voidEffects: Returns a const_reference to the maximum element.Complexity: Constant. handle_typevalue_type const &Effects: Adds a new element to the priority queue. Returns handle to elementComplexity: Constant.Note: Does not invalidate iterators. handle_typeArgs &&...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. voidvoidEffects: Removes the top element from the priority queue.Complexity: Logarithmic (amortized). Linear (worst case). voidhandle_typeconst_referenceEffects: Assigns v to the element handled by handle & updates the priority queue.Complexity: Logarithmic if current value < v, Constant otherwise. voidhandle_typeconst_referenceEffects: 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. voidhandle_typeEffects: 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! voidhandle_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. voidhandle_typeconst_referenceEffects: 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 voidhandle_typeEffects: 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! voidhandle_typeconst_referenceEffects: 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 voidhandle_typeEffects: 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! voidhandle_type const &Effects: Removes the element handled by handle from the priority_queue.Complexity: Logarithmic. iteratorvoidEffects: Returns an iterator to the first element contained in the priority queue.Complexity: Constant. iteratorvoidEffects: Returns an iterator to the end of the priority queue.Complexity: Constant. ordered_iteratorvoidEffects: Returns an ordered iterator to the first element contained in the priority queue.Note: Ordered iterators traverse the priority queue in heap order. ordered_iteratorvoidEffects: Returns an ordered iterator to the end of the priority queue.Note: Ordered iterators traverse the priority queue in heap order. voidfibonacci_heap &Effects: Merge with priority queue rhs.Complexity: Constant. value_compare const &voidEffect: Returns the value_compare object used by the priority queue boolHeapType const &Returns: Element-wise comparison of heap data structuresRequirement: the value_compare object of both heaps must match. boolHeapType const &Returns: Element-wise comparison of heap data structuresRequirement: the value_compare object of both heaps must match. boolHeapType const &Returns: Element-wise comparison of heap data structuresRequirement: the value_compare object of both heaps must match. boolHeapType const &Returns: Element-wise comparison of heap data structuresRequirement: the value_compare object of both heaps must match. boolHeapType const &Equivalent comparison Returns: True, if both heap data structures are equivalent. Requirement: the value_compare object of both heaps must match. boolHeapType 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_typeiterator 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

bool

MutablePriorityQueue PriorityQueue

boost::ForwardContainer< C >C::iterator C::const_iterator C::allocator_type C::value_compare C::value_type C::const_reference

PriorityQueue

voidHeap1 &Heap2 &merge rhs into lhsEffect: lhs contains all elements that have been part of rhs, rhs is empty.

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-183The 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

boolvoidEffects: Returns true, if the priority queue contains no elements.Complexity: Constant. size_typevoidEffects: Returns the number of elements contained in the priority queue.Complexity: Constant, if configured with constant_time_size<true>, otherwise linear. size_typevoidEffects: Returns the maximum number of elements the priority queue can contain.Complexity: Constant. voidvoidEffects: Removes all elements from the priority queue.Complexity: Linear. allocator_typevoidEffects: Returns allocator.Complexity: Constant. voidpairing_heap &Effects: Swaps two priority queues.Complexity: Constant. const_referencevoidEffects: Returns a const_reference to the maximum element.Complexity: Constant. handle_typevalue_type const &Effects: Adds a new element to the priority queue. Returns handle to elementComplexity: 2**2*log(log(N)) (amortized). handle_typeArgs &&...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). voidvoidEffects: Removes the top element from the priority queue.Complexity: Logarithmic (amortized). voidhandle_typeconst_referenceEffects: Assigns v to the element handled by handle & updates the priority queue.Complexity: 2**2*log(log(N)) (amortized). voidhandle_typeEffects: 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! voidhandle_typeconst_referenceEffects: 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 voidhandle_typeEffects: 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! voidhandle_typeconst_referenceEffects: 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 voidhandle_typeEffects: 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! voidhandle_typeEffects: Removes the element handled by handle from the priority_queue.Complexity: 2**2*log(log(N)) (amortized). iteratorvoidEffects: Returns an iterator to the first element contained in the priority queue.Complexity: Constant. iteratorvoidEffects: Returns an iterator to the end of the priority queue.Complexity: Constant. ordered_iteratorvoidEffects: Returns an ordered iterator to the first element contained in the priority queue.Note: Ordered iterators traverse the priority queue in heap order. ordered_iteratorvoidEffects: Returns an ordered iterator to the first element contained in the priority queue.Note: Ordered iterators traverse the priority queue in heap order. voidpairing_heap &Effects: Merge all elements from rhs into thisComplexity: 2**2*log(log(N)) (amortized). value_compare const &voidEffect: Returns the value_compare object used by the priority queue boolHeapType const &Returns: Element-wise comparison of heap data structuresRequirement: the value_compare object of both heaps must match. boolHeapType const &Returns: Element-wise comparison of heap data structuresRequirement: the value_compare object of both heaps must match. boolHeapType const &Returns: Element-wise comparison of heap data structuresRequirement: the value_compare object of both heaps must match. boolHeapType const &Returns: Element-wise comparison of heap data structuresRequirement: the value_compare object of both heaps must match. boolHeapType const &Equivalent comparison Returns: True, if both heap data structures are equivalent. Requirement: the value_compare object of both heaps must match. boolHeapType 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_typeiterator const &

Specifies allocator for the internal memory management. Specify arity. Specifies the arity of a D-ary heap Specifies the predicate for the heap order. Configures complexity of size() Specifies, whether size() should have linear or constant complexity. Configure heap as mutable. Certain heaps need to be configured specifically do be mutable. Specifies the type for stability counter. 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. Store parent pointer in heap node. Maintaining a parent pointer adds some maintenance and size overhead, but iterating a heap is more efficient.

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

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.

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>. 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

handle_typeskew_heap *const_reference handle_typeskew_heap *Args &&...

voidskew_heap *const_reference voidskew_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

boost::conditional< is_mutable, handle_type, void >::typevalue_type const &Effects: Adds a new element to the priority queue.Complexity: Logarithmic (amortized). boost::conditional< is_mutable, handle_type, void >::typeArgs &&...Effects: Adds a new element to the priority queue. The element is directly constructed in-place.Complexity: Logarithmic (amortized). boolvoidEffects: Returns true, if the priority queue contains no elements.Complexity: Constant. size_typevoidEffects: Returns the number of elements contained in the priority queue.Complexity: Constant, if configured with constant_time_size<true>, otherwise linear. size_typevoidEffects: Returns the maximum number of elements the priority queue can contain.Complexity: Constant. voidvoidEffects: Removes all elements from the priority queue.Complexity: Linear. allocator_typevoidEffects: Returns allocator.Complexity: Constant. voidskew_heap &Effects: Swaps two priority queues.Complexity: Constant. const_referencevoidEffects: Returns a const_reference to the maximum element.Complexity: Constant. voidvoidEffects: Removes the top element from the priority queue.Complexity: Logarithmic (amortized). iteratorvoidEffects: Returns an iterator to the first element contained in the priority queue.Complexity: Constant. iteratorvoidEffects: Returns an iterator to the end of the priority queue.Complexity: Constant. ordered_iteratorvoidEffects: Returns an ordered iterator to the first element contained in the priority queue.Note: Ordered iterators traverse the priority queue in heap order. ordered_iteratorvoidEffects: Returns an ordered iterator to the first element contained in the priority queue.Note: Ordered iterators traverse the priority queue in heap order. voidskew_heap &Effects: Merge all elements from rhs into thisComplexity: Logarithmic (amortized). value_compare const &voidEffect: Returns the value_compare object used by the priority queue boolHeapType const &Returns: Element-wise comparison of heap data structuresRequirement: the value_compare object of both heaps must match. boolHeapType const &Returns: Element-wise comparison of heap data structuresRequirement: the value_compare object of both heaps must match. boolHeapType const &Returns: Element-wise comparison of heap data structuresRequirement: the value_compare object of both heaps must match. boolHeapType const &Returns: Element-wise comparison of heap data structuresRequirement: the value_compare object of both heaps must match. boolHeapType const &Equivalent comparison Returns: True, if both heap data structures are equivalent. Requirement: the value_compare object of both heaps must match. boolHeapType const &Equivalent comparison Returns: True, if both heap data structures are not equivalent. Requirement: the value_compare object of both heaps must match. voidhandle_typeEffects: Removes the element handled by handle from the priority_queue.Complexity: Logarithmic (amortized). voidhandle_typeconst_referenceEffects: Assigns v to the element handled by handle & updates the priority queue.Complexity: Logarithmic (amortized). voidhandle_typeEffects: 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! voidhandle_typeconst_referenceEffects: 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 voidhandle_typeEffects: 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! voidhandle_typeconst_referenceEffects: 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 voidhandle_typeEffects: 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_typeiterator const &Effects: Casts an iterator to a node handle.Complexity: Constant.Requirement: data structure must be configured as mutable

node_pointerconst_reference node_pointerArgs &&... voidnode_pointer voidskew_heap const & voidnode_pointer node_pointernode_pointernode_pointernode_pointer node_pointernode_pointer node_pointernode_pointernode_pointernode_pointer voidvoid