Boost  v1.57.0
doxygen for www.boost.org
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
boost::heap::binomial_heap< T, A0, A1, A2, A3 > Class Template Reference

binomial heap More...

#include <binomial_heap.hpp>

Inheritance diagram for boost::heap::binomial_heap< T, A0, A1, A2, A3 >:
Collaboration diagram for boost::heap::binomial_heap< T, A0, A1, A2, A3 >:

Public Types

typedef T value_type
 
typedef
implementation_defined::size_type 
size_type
 
typedef
implementation_defined::difference_type 
difference_type
 
typedef
implementation_defined::value_compare 
value_compare
 
typedef
implementation_defined::allocator_type 
allocator_type
 
typedef
implementation_defined::reference 
reference
 
typedef
implementation_defined::const_reference 
const_reference
 
typedef
implementation_defined::pointer 
pointer
 
typedef
implementation_defined::const_pointer 
const_pointer
 
typedef
implementation_defined::iterator 
iterator
 Note: The iterator does not traverse the priority queue in order of the priorities. More...
 
typedef
implementation_defined::const_iterator 
const_iterator
 
typedef
implementation_defined::ordered_iterator 
ordered_iterator
 
typedef
implementation_defined::handle_type 
handle_type
 

Public Member Functions

 binomial_heap (value_compare const &cmp=value_compare())
 Effects: constructs an empty priority queue. More...
 
 binomial_heap (binomial_heap const &rhs)
 Effects: copy-constructs priority queue from rhs. More...
 
binomial_heapoperator= (binomial_heap const &rhs)
 Effects: Assigns priority queue from rhs. More...
 
 binomial_heap (binomial_heap &&rhs)
 Effects: C++11-style move constructor. More...
 
binomial_heapoperator= (binomial_heap &&rhs)
 Effects: C++11-style move assignment. More...
 
 ~binomial_heap (void)
 
bool empty (void) const
 Effects: Returns true, if the priority queue contains no elements. More...
 
size_type size (void) const
 Effects: Returns the number of elements contained in the priority queue. More...
 
size_type max_size (void) const
 Effects: Returns the maximum number of elements the priority queue can contain. More...
 
void clear (void)
 Effects: Removes all elements from the priority queue. More...
 
allocator_type get_allocator (void) const
 Effects: Returns allocator. More...
 
void swap (binomial_heap &rhs)
 Effects: Swaps two priority queues. More...
 
const_reference top (void) const
 Effects: Returns a const_reference to the maximum element. More...
 
handle_type push (value_type const &v)
 Effects: Adds a new element to the priority queue. More...
 
template<class... Args>
handle_type emplace (Args &&...args)
 Effects: Adds a new element to the priority queue. More...
 
void pop (void)
 Effects: Removes the top element from the priority queue. More...
 
void update (handle_type handle, const_reference v)
 Effects: Assigns v to the element handled by handle & updates the priority queue. More...
 
void update (handle_type handle)
 Effects: Updates the heap after the element handled by handle has been changed. More...
 
void increase (handle_type handle, const_reference v)
 Effects: Assigns v to the element handled by handle & updates the priority queue. More...
 
void increase (handle_type handle)
 Effects: Updates the heap after the element handled by handle has been changed. More...
 
void decrease (handle_type handle, const_reference v)
 Effects: Assigns v to the element handled by handle & updates the priority queue. More...
 
void decrease (handle_type handle)
 Effects: Updates the heap after the element handled by handle has been changed. More...
 
void merge (binomial_heap &rhs)
 Effects: Merge with priority queue rhs. More...
 
iterator begin (void) const
 Effects: Returns an iterator to the first element contained in the priority queue. More...
 
iterator end (void) const
 Effects: Returns an iterator to the end of the priority queue. More...
 
ordered_iterator ordered_begin (void) const
 Effects: Returns an ordered iterator to the first element contained in the priority queue. More...
 
ordered_iterator ordered_end (void) const
 Effects: Returns an ordered iterator to the end of the priority queue. More...
 
void erase (handle_type handle)
 Effects: Removes the element handled by handle from the priority_queue. More...
 
value_compare const & value_comp (void) const
 Effect: Returns the value_compare object used by the priority queue More...
 
template<typename HeapType >
bool operator< (HeapType const &rhs) const
 Returns: Element-wise comparison of heap data structures More...
 
template<typename HeapType >
bool operator> (HeapType const &rhs) const
 Returns: Element-wise comparison of heap data structures More...
 
template<typename HeapType >
bool operator>= (HeapType const &rhs) const
 Returns: Element-wise comparison of heap data structures More...
 
template<typename HeapType >
bool operator<= (HeapType const &rhs) const
 Returns: Element-wise comparison of heap data structures More...
 
template<typename HeapType >
bool operator== (HeapType const &rhs) const
 Equivalent comparison Returns: True, if both heap data structures are equivalent. More...
 
template<typename HeapType >
bool operator!= (HeapType const &rhs) const
 Equivalent comparison Returns: True, if both heap data structures are not equivalent. More...
 

Static Public Member Functions

static handle_type s_handle_from_iterator (iterator const &it)
 

Static Public Attributes

static const bool constant_time_size = super_t::constant_time_size
 
static const bool has_ordered_iterators = true
 
static const bool is_mergable = true
 
static const bool is_stable = detail::extract_stable<bound_args>::value
 
static const bool has_reserve = false
 

Friends

template<typename Heap1 , typename Heap2 >
struct heap_merge_emulate
 

Detailed Description

template<typename T, class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
class boost::heap::binomial_heap< T, A0, A1, A2, A3 >

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>

Member Typedef Documentation

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
typedef implementation_defined::allocator_type boost::heap::binomial_heap< T, A0, A1, A2, A3 >::allocator_type
template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
typedef implementation_defined::const_iterator boost::heap::binomial_heap< T, A0, A1, A2, A3 >::const_iterator
template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
typedef implementation_defined::const_pointer boost::heap::binomial_heap< T, A0, A1, A2, A3 >::const_pointer
template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
typedef implementation_defined::const_reference boost::heap::binomial_heap< T, A0, A1, A2, A3 >::const_reference
template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
typedef implementation_defined::difference_type boost::heap::binomial_heap< T, A0, A1, A2, A3 >::difference_type
template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
typedef implementation_defined::handle_type boost::heap::binomial_heap< T, A0, A1, A2, A3 >::handle_type
template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
typedef implementation_defined::iterator boost::heap::binomial_heap< T, A0, A1, A2, A3 >::iterator

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

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
typedef implementation_defined::ordered_iterator boost::heap::binomial_heap< T, A0, A1, A2, A3 >::ordered_iterator
template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
typedef implementation_defined::pointer boost::heap::binomial_heap< T, A0, A1, A2, A3 >::pointer
template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
typedef implementation_defined::reference boost::heap::binomial_heap< T, A0, A1, A2, A3 >::reference
template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
typedef implementation_defined::size_type boost::heap::binomial_heap< T, A0, A1, A2, A3 >::size_type
template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
typedef implementation_defined::value_compare boost::heap::binomial_heap< T, A0, A1, A2, A3 >::value_compare
template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
typedef T boost::heap::binomial_heap< T, A0, A1, A2, A3 >::value_type

Constructor & Destructor Documentation

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
boost::heap::binomial_heap< T, A0, A1, A2, A3 >::binomial_heap ( value_compare const &  cmp = value_compare())
inlineexplicit

Effects: constructs an empty priority queue.

Complexity: Constant.

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
boost::heap::binomial_heap< T, A0, A1, A2, A3 >::binomial_heap ( binomial_heap< T, A0, A1, A2, A3 > const &  rhs)
inline

Effects: copy-constructs priority queue from rhs.

Complexity: Linear.

References boost::heap::binomial_heap< T, A0, A1, A2, A3 >::empty().

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
boost::heap::binomial_heap< T, A0, A1, A2, A3 >::binomial_heap ( binomial_heap< T, A0, A1, A2, A3 > &&  rhs)
inline

Effects: C++11-style move constructor.

Complexity: Constant.

Note: Only available, if BOOST_NO_CXX11_RVALUE_REFERENCES is not defined

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
boost::heap::binomial_heap< T, A0, A1, A2, A3 >::~binomial_heap ( void  )
inline

Member Function Documentation

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
iterator boost::heap::binomial_heap< T, A0, A1, A2, A3 >::begin ( void  ) const
inline

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

Complexity: Constant.

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
void boost::heap::binomial_heap< T, A0, A1, A2, A3 >::clear ( void  )
inline

Effects: Removes all elements from the priority queue.

Complexity: Linear.

Referenced by boost::heap::binomial_heap< T, A0, A1, A2, A3 >::operator=(), and boost::heap::binomial_heap< T, A0, A1, A2, A3 >::~binomial_heap().

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
void boost::heap::binomial_heap< T, A0, A1, A2, A3 >::decrease ( handle_type  handle,
const_reference  v 
)
inline

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

Referenced by boost::heap::binomial_heap< T, A0, A1, A2, A3 >::update().

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
void boost::heap::binomial_heap< T, A0, A1, A2, A3 >::decrease ( handle_type  handle)
inline

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!

References boost::n.

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
template<class... Args>
handle_type boost::heap::binomial_heap< T, A0, A1, A2, A3 >::emplace ( Args &&...  args)
inline

Effects: Adds a new element to the priority queue.

The element is directly constructed in-place. Returns handle to element.

Complexity: Logarithmic.

References boost::python::args(), boost::numeric::ublas::increment(), and boost::n.

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
bool boost::heap::binomial_heap< T, A0, A1, A2, A3 >::empty ( void  ) const
inline
template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
iterator boost::heap::binomial_heap< T, A0, A1, A2, A3 >::end ( void  ) const
inline

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

Complexity: Constant.

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
void boost::heap::binomial_heap< T, A0, A1, A2, A3 >::erase ( handle_type  handle)
inline

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

Complexity: Logarithmic.

References boost::n, and boost::heap::binomial_heap< T, A0, A1, A2, A3 >::pop().

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
allocator_type boost::heap::binomial_heap< T, A0, A1, A2, A3 >::get_allocator ( void  ) const
inline

Effects: Returns allocator.

Complexity: Constant.

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
void boost::heap::binomial_heap< T, A0, A1, A2, A3 >::increase ( handle_type  handle,
const_reference  v 
)
inline

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

Referenced by boost::heap::binomial_heap< T, A0, A1, A2, A3 >::update().

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
void boost::heap::binomial_heap< T, A0, A1, A2, A3 >::increase ( handle_type  handle)
inline

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!

References boost::n.

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
size_type boost::heap::binomial_heap< T, A0, A1, A2, A3 >::max_size ( void  ) const
inline

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

Complexity: Constant.

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
void boost::heap::binomial_heap< T, A0, A1, A2, A3 >::merge ( binomial_heap< T, A0, A1, A2, A3 > &  rhs)
inline
template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
template<typename HeapType >
bool boost::heap::binomial_heap< T, A0, A1, A2, A3 >::operator!= ( HeapType const &  rhs) const
inline

Equivalent comparison Returns: True, if both heap data structures are not equivalent.

Requirement: the value_compare object of both heaps must match.

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
template<typename HeapType >
bool boost::heap::binomial_heap< T, A0, A1, A2, A3 >::operator< ( HeapType const &  rhs) const
inline

Returns: Element-wise comparison of heap data structures

Requirement: the value_compare object of both heaps must match.

Referenced by boost::heap::binomial_heap< T, A0, A1, A2, A3 >::operator>=().

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
template<typename HeapType >
bool boost::heap::binomial_heap< T, A0, A1, A2, A3 >::operator<= ( HeapType const &  rhs) const
inline

Returns: Element-wise comparison of heap data structures

Requirement: the value_compare object of both heaps must match.

References boost::heap::binomial_heap< T, A0, A1, A2, A3 >::operator>().

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
binomial_heap& boost::heap::binomial_heap< T, A0, A1, A2, A3 >::operator= ( binomial_heap< T, A0, A1, A2, A3 > const &  rhs)
inline

Effects: Assigns priority queue from rhs.

Complexity: Linear.

References boost::heap::binomial_heap< T, A0, A1, A2, A3 >::clear(), and boost::heap::binomial_heap< T, A0, A1, A2, A3 >::empty().

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
binomial_heap& boost::heap::binomial_heap< T, A0, A1, A2, A3 >::operator= ( binomial_heap< T, A0, A1, A2, A3 > &&  rhs)
inline

Effects: C++11-style move assignment.

Complexity: Constant.

Note: Only available, if BOOST_NO_CXX11_RVALUE_REFERENCES is not defined

References boost::heap::binomial_heap< T, A0, A1, A2, A3 >::clear(), boost::fusion::move(), and boost::heap::detail::make_binomial_heap_base< T, Parspec >::type::operator=().

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
template<typename HeapType >
bool boost::heap::binomial_heap< T, A0, A1, A2, A3 >::operator== ( HeapType const &  rhs) const
inline

Equivalent comparison Returns: True, if both heap data structures are equivalent.

Requirement: the value_compare object of both heaps must match.

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
template<typename HeapType >
bool boost::heap::binomial_heap< T, A0, A1, A2, A3 >::operator> ( HeapType const &  rhs) const
inline

Returns: Element-wise comparison of heap data structures

Requirement: the value_compare object of both heaps must match.

Referenced by boost::heap::binomial_heap< T, A0, A1, A2, A3 >::operator<=().

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
template<typename HeapType >
bool boost::heap::binomial_heap< T, A0, A1, A2, A3 >::operator>= ( HeapType const &  rhs) const
inline

Returns: Element-wise comparison of heap data structures

Requirement: the value_compare object of both heaps must match.

References boost::heap::binomial_heap< T, A0, A1, A2, A3 >::operator<().

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
ordered_iterator boost::heap::binomial_heap< T, A0, A1, A2, A3 >::ordered_begin ( void  ) const
inline

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

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

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
ordered_iterator boost::heap::binomial_heap< T, A0, A1, A2, A3 >::ordered_end ( void  ) const
inline

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

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

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
void boost::heap::binomial_heap< T, A0, A1, A2, A3 >::pop ( void  )
inline
template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
handle_type boost::heap::binomial_heap< T, A0, A1, A2, A3 >::push ( value_type const &  v)
inline

Effects: Adds a new element to the priority queue.

Returns handle to element

Complexity: Logarithmic.

References boost::numeric::ublas::increment(), and boost::n.

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
static handle_type boost::heap::binomial_heap< T, A0, A1, A2, A3 >::s_handle_from_iterator ( iterator const &  it)
inlinestatic

References boost::python::ptr().

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
size_type boost::heap::binomial_heap< T, A0, A1, A2, A3 >::size ( void  ) const
inline

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

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

References boost::heap::binomial_heap< T, A0, A1, A2, A3 >::empty().

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
void boost::heap::binomial_heap< T, A0, A1, A2, A3 >::swap ( binomial_heap< T, A0, A1, A2, A3 > &  rhs)
inline

Effects: Swaps two priority queues.

Complexity: Constant.

References boost::swap.

Referenced by boost::heap::binomial_heap< T, A0, A1, A2, A3 >::merge(), and boost::heap::binomial_heap< T, A0, A1, A2, A3 >::pop().

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
const_reference boost::heap::binomial_heap< T, A0, A1, A2, A3 >::top ( void  ) const
inline

Effects: Returns a const_reference to the maximum element.

Complexity: Constant.

References BOOST_ASSERT, and boost::heap::binomial_heap< T, A0, A1, A2, A3 >::empty().

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
void boost::heap::binomial_heap< T, A0, A1, A2, A3 >::update ( handle_type  handle,
const_reference  v 
)
inline

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

Complexity: Logarithmic.

References boost::heap::binomial_heap< T, A0, A1, A2, A3 >::decrease(), and boost::heap::binomial_heap< T, A0, A1, A2, A3 >::increase().

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
void boost::heap::binomial_heap< T, A0, A1, A2, A3 >::update ( handle_type  handle)
inline

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!

References boost::heap::binomial_heap< T, A0, A1, A2, A3 >::decrease(), and boost::heap::binomial_heap< T, A0, A1, A2, A3 >::increase().

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
value_compare const& boost::heap::binomial_heap< T, A0, A1, A2, A3 >::value_comp ( void  ) const
inline

Effect: Returns the value_compare object used by the priority queue

Referenced by boost::heap::binomial_heap< T, A0, A1, A2, A3 >::pop().

Friends And Related Function Documentation

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
template<typename Heap1 , typename Heap2 >
friend struct heap_merge_emulate
friend

Member Data Documentation

template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
const bool boost::heap::binomial_heap< T, A0, A1, A2, A3 >::constant_time_size = super_t::constant_time_size
static
template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
const bool boost::heap::binomial_heap< T, A0, A1, A2, A3 >::has_ordered_iterators = true
static
template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
const bool boost::heap::binomial_heap< T, A0, A1, A2, A3 >::has_reserve = false
static
template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
const bool boost::heap::binomial_heap< T, A0, A1, A2, A3 >::is_mergable = true
static
template<typename T , class A0 = boost::parameter::void_, class A1 = boost::parameter::void_, class A2 = boost::parameter::void_, class A3 = boost::parameter::void_>
const bool boost::heap::binomial_heap< T, A0, A1, A2, A3 >::is_stable = detail::extract_stable<bound_args>::value
static

The documentation for this class was generated from the following file: