斐波那契堆

斐波那契堆对一个集合支持以下操作：
（1）向集合插入一个元素（均摊复杂度log(n)）;
（2）集合最小值（O(1)）;
（3）删除最小值（O(log(n))）;
（4）两个斐波那契堆合并(均摊复杂度O(1)) ;
（5）将其中某个元素的值更改为另一个更小的值(均摊复杂度O(1));
（6）删除一个元素(log(n)).

#include <cmath>
#include <algorithm>
#include <new>
#include <assert.h>
using namespace std;


template<typename Type>
class FibonacciHeap
{
public:
    typedef Type value_type;
    typedef Type& reference;
private:
    struct FibonacciHeapNode
    {
        value_type key;
        int degree;
        FibonacciHeapNode* left;
        FibonacciHeapNode* right;
        FibonacciHeapNode* father;
        FibonacciHeapNode* son;
        bool marked;

        ~FibonacciHeapNode()
        {
            left=right=father=son=NULL;
        }
    };
public:
    typedef FibonacciHeapNode* iterator;

private:
    FibonacciHeapNode* m_MinNode;
    int m_NodeNumber;
    value_type m_MinValue;
    FibonacciHeapNode** m_ArrForConsolidate;
    int m_ArrForConsolidateSize;

    FibonacciHeapNode* newNode()
    {
        FibonacciHeapNode* node=new FibonacciHeapNode;
        node->left=NULL;
        node->right=NULL;
        node->father=NULL;
        node->son=NULL;
        node->marked=false;
        node->degree=0;

        return node;
    }

    /**
       将a插入b之前
    **/
    void insertNode(FibonacciHeapNode *a,FibonacciHeapNode*b)
    {
        a->left=b->left;
        b->left->right=a;
        a->right=b;
        b->left=a;
    }

    void linkHeap(FibonacciHeapNode* y,FibonacciHeapNode* x)
    {
        y->left->right=y->right;
        y->right->left=y->right;
        if(x->son==NULL)
        {
            x->son=y;
            y->left=y->right=y;

        }
        else
        {
            insertNode(y,x->son);
        }
        y->father=x;
        y->marked=false;
        x->degree++;

    }

    /***
       合并根链表 直到根链表上每一个根有不同的度数(degree)
    **/
    void consolidate()
    {
        int MAXDEGREE=int(log2(m_NodeNumber))*3;
        FibonacciHeapNode* cur=m_MinNode;
        int rootChainNodeNum=0;
        do
        {
            if(cur->degree>MAXDEGREE) MAXDEGREE=cur->degree;
            cur=cur->left;
            rootChainNodeNum++;
        }while(cur!=m_MinNode);


        if(m_ArrForConsolidateSize<MAXDEGREE)
        {
            if(m_ArrForConsolidateSize) delete[] m_ArrForConsolidate;
            m_ArrForConsolidateSize=MAXDEGREE*2+1;
            m_ArrForConsolidate=new (std::nothrow)FibonacciHeapNode*[m_ArrForConsolidateSize];
        }


        for(int i=0;i<=MAXDEGREE;i++) m_ArrForConsolidate[i]=NULL;
        cur=m_MinNode;
        for(int i=0;i<rootChainNodeNum;i++)
        {
            FibonacciHeapNode* x=cur;
            FibonacciHeapNode* next=cur->left;
            int d=x->degree;
            x->left=x->right=x;
            while(m_ArrForConsolidate[d]!=NULL)
            {
                FibonacciHeapNode* y=m_ArrForConsolidate[d];
                if(x->key>y->key)
                {
                    FibonacciHeapNode* tmp=x;
                    x=y;
                    y=tmp;
                }
                linkHeap(y,x);
                m_ArrForConsolidate[d++]=NULL;
            }
            m_ArrForConsolidate[d]=x;
            cur=next;
        }

        m_MinNode=NULL;
        for(int i=0;i<=MAXDEGREE;i++)
        {
            if(m_ArrForConsolidate[i]!=NULL)
            {
                if(m_MinNode==NULL)
                {
                    m_MinNode=m_ArrForConsolidate[i];
                    m_MinNode->left=m_MinNode->right=m_MinNode;
                }
                else
                {
                    insertNode(m_ArrForConsolidate[i],m_MinNode);
                    if(m_ArrForConsolidate[i]->key<m_MinNode->key)
                    {
                        m_MinNode=m_ArrForConsolidate[i];
                    }

                }
            }
        }
    }

    /**
       x是y的儿子 切下x 并把x接入根链表
    **/
    void cut(FibonacciHeapNode*x,FibonacciHeapNode*y)
    {
        /**
          y只有这个一个儿子
        **/
        if(x->left==x)
        {
            y->son=NULL;
        }
        else
        {
            x->left->right=x->right;
            x->right->left=x->left;
            if(y->son==x)
            {
                y->son=x->left;
            }
        }
        insertNode(x,m_MinNode);
        x->father=NULL;
        x->marked=false;
        y->degree--;
    }

    void cascadingCut(FibonacciHeapNode* y)
    {
        FibonacciHeapNode* z=y->father;
        if(z!=NULL)
        {
            if(y->marked==false) y->marked=true;
            else
            {
                cut(y,z);
                cascadingCut(z);
            }
        }
    }

    iterator search(FibonacciHeapNode* cur,const reference key)
    {
        if(cur==NULL) return NULL;

        FibonacciHeapNode* tmp=cur;
        do
        {
            if(tmp->key==key) return tmp;
            FibonacciHeapNode* ans=search(tmp->son,key);
            if(ans) return ans;
            tmp=tmp->left;
        }while(tmp!=cur);
        return NULL;
    }

    void freeAll(FibonacciHeapNode* rt)
    {
        int sum=0;
        FibonacciHeapNode* cur=rt;
        do
        {
            sum++;
            cur=cur->left;
        }while(cur!=rt);
        for(int i=0;i<sum;i++)
        {
            FibonacciHeapNode* next=cur->left;
            if(cur->son) freeAll(cur->son);
            delete cur;
            cur=next;
        }
    }

public:
    FibonacciHeap(value_type MinValue):
        m_MinNode(NULL),m_NodeNumber(0),m_MinValue(MinValue),m_ArrForConsolidateSize(0){}

    ~FibonacciHeap()
    {
        if(m_ArrForConsolidateSize>0) delete[] m_ArrForConsolidate;
        if(m_MinNode) freeAll(m_MinNode);
    }

    void insert(const reference key)
    {
        FibonacciHeapNode* x=newNode();
        x->key=key;
        if(m_MinNode==NULL)
        {
            x->left=x->right=x;
            m_MinNode=x;
        }
        else
        {
            assert(x);
            insertNode(x,m_MinNode);
            if(x->key<m_MinNode->key) m_MinNode=x;
        }
        m_NodeNumber++;
    }

    value_type getMinValue()
    {
        return m_MinNode->key;
    }

    /**
       将h合并到该树上
       之后将销毁h
    **/
    void UnionHeap(FibonacciHeap* &h)
    {
        if(h->m_MinNode==NULL) return;

        if(m_MinNode==NULL)
        {
            m_MinNode=h->m_MinNode;
            m_NodeNumber=h->m_NodeNumber;
        }
        else
        {
            FibonacciHeapNode* S=h->m_MinNode;
            FibonacciHeapNode* E=S->right;

            FibonacciHeapNode* curS=m_MinNode;
            FibonacciHeapNode* curE=curS->right;
            E->left=curS;
            curS->right=E;
            curE->left=S;
            S->right=curE;

            if(h->m_MinNode->key<m_MinNode->key)
            {
                m_MinNode=h->m_MinNode;
            }
        }

        m_NodeNumber+=h->m_NodeNumber;
        delete[] h;
        h=NULL;
    }

    void removeMinValue()
    {
        if(m_MinNode==NULL) return;
        FibonacciHeapNode* z=m_MinNode;
        if(z->son)
        {
            FibonacciHeapNode* sonBegin=z->son;
            FibonacciHeapNode* curSon=sonBegin;
            int chainNum=0;
            do
            {
                curSon->father=NULL;
                curSon=curSon->left;
                chainNum++;
            }while(curSon!=sonBegin);
            curSon=sonBegin;
            for(int i=0;i<chainNum;i++)
            {
                FibonacciHeapNode* next=curSon->left;
                insertNode(curSon,m_MinNode);
                curSon=next;
            }
        }

        if(z->left==z)
        {
            m_MinNode=NULL;
        }
        else
        {
            z->left->right=z->right;
            z->right->left=z->left;
            m_MinNode=z->left;
            consolidate();
        }
        delete z;
        m_NodeNumber--;
    }

    void decreaseKey(FibonacciHeapNode* x,const reference key)
    {
        assert(x&&x->key>key);
        x->key=key;
        FibonacciHeapNode* y=x->father;
        if(y!=NULL&&x->key<y->key)
        {
            cut(x,y);
            cascadingCut(y);
        }
        if(x->key<m_MinNode->key) m_MinNode=x;
    }

    /**
      删除指针x
    **/
    void remove(FibonacciHeapNode* x)
    {
        if(x==NULL) return;
        decreaseKey(x,m_MinValue);
        removeMinValue();
    }

    /**
      删除x
    **/
    void remove(const reference x)
    {
        remove(search(x));
    }

    /**
      查找key 返回一个指针 找不到返回NULL
    **/
    iterator search(const reference key)
    {
        return search(m_MinNode,key);
    }

};