|
Template Class lazy_fibonacci_heap<T, Comp>
Synopsis
|
#include "boost/l_heap.hpp"
template <class T>
class boost::lazy_fibonacci_heap_base
{
public:
class iterator
{
public:
iterator();
bool operator== (iterator const& it) const;
bool operator!= (iterator const& it) const;
T const& operator* () const;
T const* operator-> () const;
iterator &operator++ ();
iterator operator++ (int);
};
public:
bool empty() const;
size_type size() const;
iterator begin() const;
iterator end() const;
private:
lazy_fibonacci_heap_base(lazy_fibonacci_heap_base const&); // deliberately not implemented
void operator= (lazy_fibonacci_heap_base const&); // deliberately not implemented
};
template <class T, class Comp = std::less<T> >
class boost::lazy_fibonacci_heap: public boost::lazy_fibonacci_heap_base<T>
{
public:
typedef unsigned integral type size_type;
typedef pointer type pointer;
typedef T value_type;
typedef T const& const_reference;
typedef typename lazy_fibonacci_heap_base<T>::iterator const_iterator;
typedef Comp compare_type;
explicit lazy_fibonacci_heap(Comp const& comp = Comp());
pointer push(T const& val);
void pop();
T const& top() const;
void remove(pointer ptr);
template <typename K> void change_top(K const& val);
template <typename K> void change(pointer ptr, K const& val);
template <typename K> void decrease(pointer ptr, K const& val);
template <typename K> void increase(pointer ptr, K const& val);
};
|
Description
This class is a variation on Fibonacci heaps which seems
to provide better performance if there are a lot operations changing the priority
of the elements. The idea of this class is to avoid work as long as it is not
necessary to do the work (a very obvious approach which I also apply in real
life). This way, some work can be avoided all together. The work which can
be avoided are the necessary link operations when a node is made a root
until the maximum element is to be accessed. Thus, whenever a node is made
a root, it is actually stored in a list of pending roots. This list is
processed and made real roots when the maximum element of the priority queue
is accessed (eg. using top()). I have
no clue whether the asymptotical behavior of Fibonacci heaps is messed up
with this approach but my feeling is that it is not messed up (but I have
no formal proof).
For a description of the methods of lazy_fibonacci_heap<T, Comp> see the
description of common methods.
See Also
f_heap(3),
heap(3),
heap-common(3)
Copyright © 1999 Dietmar Kühl (dietmar.kuehl@claas-solutions.de)
Claas Solutions GmbH
|