Binomial Heap

        花一下午写的一个二项堆的C++实现，思想源自Robert Sedgewick 的 Algorithms in C。

 

        首先说下性能。复杂度没什么好说的，merge, push, pop, top, size, empty 都是O(lgn)，下面讲一下本机测试的数据。

 

        (host) Pent. dual-core t3200, 2G hz, 2G ram, (OS) linux 2.6.32，(compiler) gcc 4.5.2

 

        输入 0~n-1的自然数，n = 100000000，一亿

 

        n次push很快，7秒，因为是链式树的实现，甚至比std::priority_queue还要快，后者10秒，但是pop就太不堪了，为标准库的2倍多，

 

        n次push后的析构，花 4秒，唉，都超过push的一半了，std::priority_queue是随机访问序列的适配器，其析构自然是瞬杀了。

 

        这样比起来，其实也很一般。

 

        好吧，我知道不能这么比，二项堆就是二项堆，全O(lgn)操作的数据结构，最主要的是merge。

 

       不得不说， Mr. Sedgewick 的算法解说非常棒，但是其代码，真的太那个了。下面贴出代码，以私有方法insert为主体，模仿二进制加法进行合并式插入。

 

       （PS. 按 Mr. Sedgewick描述的，以简单的二的幂堆的集合为基础进行实现。翻了下算法导论，里面的图解很晕人，没仔细研究，也不知用的什么方法）

 

     // binomial_heap.hpp // 名字约定，所有函数参数均以双下划线__开头，其他没什么特别了 // 另：空行全被吃了，所以用注释行代替了 #ifndef BINOMIAL_HEAP_HPP_INCLUDE #define BINOMIAL_HEAP_HPP_INCLUDE // #ifndef IT_NAMESPACE_DEF #define IT_NAMESPACE_BEGIN namespace it { // 本来想叫extra or extend or ext的，但又太频繁了，就直接叫 it 了，表示第三方的 #define IT_NAMESPACE_END } #define IT_NAMESPACE_DEF #endif // IT_NAMESPACE_DEF // #include <algorithm> #include <functional> #include <memory> #include <stdexcept> // IT_NAMESPACE_BEGIN // template <typename T> struct tree_node { T value; tree_node *left; tree_node *right; }; // template <typename T, typename AllocT> inline tree_node<T> * clone_node(tree_node<T> *__root, AllocT &__al) // 从给定的根开始复制树，被copy-ctor调用进行深拷贝 { typedef typename AllocT:: template rebind<tree_node<T> >::other tree_node_allocator; // if (__root) { tree_node<T> *copy = tree_node_allocator(__al).allocate(1); __al.construct(&(copy -> value), __root -> value); copy -> left = clone_node(__root -> left, __al); copy -> right = clone_node(__root -> right, __al); return copy; } return 0; } // template <typename T, typename AllocT> inline void clean_node(tree_node<T> *__root, AllocT &__al) // 清理给定的根的树，被dtor调用（不得不说这个操作非常慢） { typedef typename AllocT:: template rebind<tree_node<T> >::other tree_node_allocator; if (__root) { clean_node(__root -> left, __al); clean_node(__root -> right, __al); tree_node_allocator(__al).deallocate(__root, 1); } } // template <typename T, typename CompT> inline tree_node<T> * merge_node(tree_node<T> *__root1, tree_node<T> *__root2, const CompT &__op) // 合并两树并返回新树的根，专门由binomial_heap的方法契约式调用，所以没有安全检查及通用性保障（实际上参数树会失效，用指针引用能增加保障，这里忽略） { tree_node<T> *root; if (__op(__root1 -> value, __root2 -> value)) { root = __root2; __root1 -> right = root -> left; root -> left = __root1; } else { root = __root1; __root2 -> right = root -> left; root -> left = __root2; } return root; } // template <typename T, typename CompT = std::less<T>, typename AllocT = std::allocator<T> > class binomial_heap { typedef tree_node<T> node_type; typedef typename AllocT:: template rebind<node_type>::other node_allocator_type; // 树（二的幂堆）结点的分配器类型 // public: typedef T value_type; typedef CompT compare_type; typedef AllocT allocator_type; typedef typename AllocT::size_type size_type; // binomial_heap(); explicit binomial_heap(const CompT &__op); binomial_heap(const CompT &__op, const AllocT &__al); binomial_heap(const binomial_heap &__other); ~binomial_heap(); // binomial_heap<T, CompT, AllocT> & operator=(const binomial_heap &__other); // void merge(binomial_heap &__other); void push(const value_type &__x); void pop(); value_type top() const; size_type size() const; bool empty() const; // private: compare_type op; allocator_type al; // enum { N = 8 * sizeof(size_type), }; // tops 为 2的幂堆的集合，每一个子堆对应结点总数的二进位，相应的，tops[i]最多能容纳2^i个元素，考虑到机器能表示的最大数位，将最大容量适当的设为2^N-1 node_type *tops[N]; // array of power heaps // void insert(node_type *item, size_type pos); node_type **max_top() const; // std::priority_heap<>以less<>为默认排序子得到大堆，这里类似处理 // struct MaxTopComp // 将被std::max_element调用 { const compare_type &op; MaxTopComp(const compare_type &__op) : op(__op) { } bool operator()(const node_type *a, const node_type *b) const { if (a == 0) return true; if (b == 0) return false; return op(a -> value, b -> value); } }; }; // // public methods // template <typename T, typename CompT, typename AllocT> inline binomial_heap<T, CompT, AllocT>:: binomial_heap() : op(CompT()), al(AllocT()), tops() // tops() 数组的置0初始化，来自C++98，非常重要的一步 { } // template <typename T, typename CompT, typename AllocT> inline binomial_heap<T, CompT, AllocT>:: binomial_heap(const CompT &__op) : op(__op), al(AllocT()), tops() // 0初始化，不可缺省 { } // template <typename T, typename CompT, typename AllocT> inline binomial_heap<T, CompT, AllocT>:: binomial_heap(const CompT &__op, const AllocT &__al) : op(__op), al(__al), tops() // 0初始化 { } // template <typename T, typename CompT, typename AllocT> inline binomial_heap<T, CompT, AllocT>:: binomial_heap(const binomial_heap<T, CompT, AllocT> &__other) : op(__other.op), al(__other.al) { // copy tops （在clone_node中对 0 值已有处理） std::transform(__other.tops, __other.tops + N, tops, std::bind2nd(std::ptr_fun(clone_node<T, AllocT>), al)); } // template <typename T, typename CompT, typename AllocT> inline binomial_heap<T, CompT, AllocT>:: ~binomial_heap() { std::for_each(tops, tops + N, std::bind2nd(std::ptr_fun(clean_node<T, AllocT>), al)); } // template <typename T, typename CompT, typename AllocT> inline binomial_heap<T, CompT, AllocT> & binomial_heap<T, CompT, AllocT>:: operator=(const binomial_heap<T, CompT, AllocT> &__other) { if (this != &__other) { binomial_heap<T, CompT, AllocT> copy(__other); // 异常安全式的写法 std::swap(op, copy.op); std::swap(al, copy.al); std::swap_ranges(tops, tops + N, copy.tops); } return *this; } // template <typename T, typename CompT, typename AllocT> inline void binomial_heap<T, CompT, AllocT>:: merge(binomial_heap<T, CompT, AllocT> &__other) { for (size_t i = 0; i < N; ++i) if (__other.tops[i]) { insert(__other.tops[i], i); // 二进制加法式的合并 __other.tops[i] = 0; } } // template <typename T, typename CompT, typename AllocT> inline void binomial_heap<T, CompT, AllocT>:: push(const value_type &__x) { node_type *tmp = node_allocator_type(al).allocate(1); tmp -> left = tmp -> right = 0; al.construct(&(tmp -> value), __x); insert(tmp, 0); } // template <typename T, typename CompT, typename AllocT> inline void binomial_heap<T, CompT, AllocT>:: pop() { size_type offset = max_top() - tops; // 相应二的幂堆根的位置 node_type *root = tops[offset] -> left; // root of the complete binary tree (node_allocator_type(al)).deallocate(tops[offset], 1); tops[offset] = 0; // 这一步置0极为重要，提供实现的完整性保障，所有方法直接或间接依赖它 // 删除二的幂堆的根，其子树为一棵完全二叉树，延右路径分解成多个二的幂堆，其幂数依次递减。实际上对这种pop实现的性能O(lgn)我保持怀疑态度，经测试，连续n次pop速度真的很慢，这里n的实值为一亿 while (root) { node_type *subRoot = root -> right; insert(root, --offset); root = subRoot; } } // template <typename T, typename CompT, typename AllocT> inline typename binomial_heap<T, CompT, AllocT>::value_type binomial_heap<T, CompT, AllocT>:: top() const { return (*max_top()) -> value; } // template <typename T, typename CompT, typename AllocT> inline typename binomial_heap<T, CompT, AllocT>::size_type binomial_heap<T, CompT, AllocT>:: size() const { size_type n = 0; for (size_type i = 0; i < N; ++i) if (tops[i]) n += 1 << i; // 想一想二进制是如何化成十进制的 return n; } // template <typename T, typename CompT, typename AllocT> inline bool binomial_heap<T, CompT, AllocT>:: empty() const { return std::count(tops, tops + N, (void *)0) == N; } // // private methods // template <typename T, typename CompT, typename AllocT> inline void binomial_heap<T, CompT, AllocT>:: insert(node_type *__item, size_type __offset) { while (__offset < N) { // 依二进制加法，遇2进位（合并对应位，树__item的大小增加一倍，继续合并下一位或直接插入） if (tops[__offset]) { __item = merge_node(__item, tops[__offset], op); // 契约：仅两树大小相等（图形完全一致）才能合并 tops[__offset++] = 0; // 旧位置 0 } else break; } if (__offset == N) throw std::overflow_error("binomial heap overflow"); tops[__offset] = __item; // 找到空位，直接放入 } // template <typename T, typename CompT, typename AllocT> inline typename binomial_heap<T, CompT, AllocT>::node_type ** binomial_heap<T, CompT, AllocT>:: max_top() const { // const 方法，std::max_element 将返回 node_type * const *，强转 return const_cast<node_type **>(std::max_element(tops, tops + N, MaxTopComp(op))); } // IT_NAMESPACE_END // #endif // BINOMIAL_HEAP_HPP_INCLUDE