|  | Home | Libraries | People | FAQ | More | 
      boost.heap provides the following data structures:
    
boost::heap::priority_queue
            The priority_queue
            class is a wrapper to the stl heap functions. It implements a heap as
            container adaptor ontop of a std::vector and is immutable.
          
boost::heap::d_ary_heap
            D-ary heaps
            are a generalization of binary heap with each non-leaf node having N
            children. For a low arity, the height of the heap is larger, but the
            number of comparisons to find the largest child node is bigger. D-ary
            heaps are implemented as container adaptors based on a std::vector.
          
The data structure can be configured as mutable. This is achieved by storing the values inside a std::list.
boost::heap::binomial_heapBinomial heaps are node-base heaps, that are implemented as a set of binomial trees of piecewise different order. The most important heap operations have a worst-case complexity of O(log n). In contrast to d-ary heaps, binomial heaps can also be merged in O(log n).
boost::heap::fibonacci_heap
            Fibonacci heaps
            are node-base heaps, that are implemented as a forest of heap-ordered
            trees. They provide better amortized performance than binomial heaps.
            Except pop() and erase(), the most
            important heap operations have constant amortized complexity.
          
boost::heap::pairing_heapPairing heaps are self-adjusting node-based 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
boost::heap::skew_heapSkew heaps are self-adjusting node-based heaps. Although there are no constraints for the tree structure, all heap operations can be performed in O(log n).
Table 16.1. Comparison of amortized complexity
| 
                 | 
                 | 
                 | 
                 | 
                 | 
                 | 
                 | 
                 | |
|---|---|---|---|---|---|---|---|---|
| 
                 | O(log(N)) | O(log(N)) | n/a | n/a | n/a | n/a | O((N+M)*log(N+M)) | |
| 
                 | O(log(N)) | O(log(N)) | O(log(N)) | O(log(N)) | O(log(N)) | O(log(N)) | O((N+M)*log(N+M)) | |
| 
                 | O(log(N)) | O(log(N)) | O(log(N)) | O(log(N)) | O(log(N)) | O(log(N)) | O(log(N+M)) | |
| 
                 | O(1) | O(log(N)) | O(log(N)) [a] | O(1) | O(log(N)) | O(log(N)) | O(1) | |
| 
                 | O(2**2*log(log(N))) | O(log(N)) | O(2**2*log(log(N))) | O(2**2*log(log(N))) | O(2**2*log(log(N))) | O(2**2*log(log(N))) | O(2**2*log(log(N))) | |
| 
                 | O(log(N)) | O(log(N)) | O(log(N)) | O(log(N)) | O(log(N)) | O(log(N)) | O(log(N+M)) | |
| [a] 
                  The fibonacci a  | ||||||||
The data structures can be configured with Boost.Parameter-style templates.
boost::heap::compare
              Predicate for defining the heap order, optional (defaults to boost::heap::compare<std::less<T>
              >)
            
boost::heap::allocator
              Allocator for internal memory management, optional (defaults to boost::heap::allocator<std::allocator<T>
              >)
            
boost::heap::stable
              Configures the heap to use a stable
              heap order, optional (defaults to boost::heap::stable<false>).
            
boost::heap::mutable_
              Configures the heap to be mutable. boost::heap::d_ary_heap
              and boost::heap::skew_heap
              have to be configured with this policy to enable the mutability
              interface.
            
boost::heap::stability_counter_type
              Configures the integer type used for the stability counter, optional
              (defaults to boost::heap::stability_counter_type<boost::uintmax_t>).
              For more details, consult the Stability
              section.
            
boost::heap::constant_time_size
              Specifies, whether size() should have linear or
              constant complexity. This argument is only available for node-based
              heap data structures and if available, it is optional (defaults to
              boost::heap::constant_time_size<true>)
            
boost::heap::arity
              Specifies the arity of a d-ary heap. For details, please consult the
              class reference of boost::heap::d_ary_heap
            
boost::heap::store_parent_pointer
              Store the parent pointer in the heap nodes. This policy is only available
              in the boost::heap::skew_heap.