fibonacci-Heap（斐波那契堆）原理及C++代码实现

斐波那契堆是一种高级的堆结构，建议与二项堆一起食用效果更佳。

斐波那契堆是一个摊还性质的数据结构，很多堆操作在斐波那契堆上的摊还时间都很低，达到了θ（1）的程度，取最小值和删除操作的时间复杂度是O（lgn）。

斐波那契堆的关键操作我觉得是合并树和级联剪切。下面我简要地说一些关于这两个方法的体会。

斐波那契堆深度的增加应该就是通过合并树（consolidate）这个操作，如果没有剪切的影响，那么consolidate后的堆非常类似与二项堆。

级联剪切操作则是减小堆深度的操作，我在学习的时候一直有个问题，就是为什么级联剪切一定要失去第二个子结点时才开始剪切？为什么恰恰是二，而不是第三个或其他数？后来我看到一个大佬的博客写的是，这样可以尽量保证斐波那契堆可以类似于二项堆，防止“越剪越乱”。这个解释也是目前我最接受的。

所以可以看到的是斐波那契堆其实可以看做一个宽松的二项堆。

代码如下：（仅供参考）

class FibHeap {
private :
    struct Node {
        Node * parent;
        Node * child;
        Node * left;
        Node * right;
        int key;
        int degree; //degree of children
        bool mark; //whether lose any child
        Node() : parent(nullptr), child(nullptr), left(this), right(this),
                 key(0), degree(0), mark(false) {}
    };
private :
    Node * min; //pointer to the minimum node of heap
    int n;
private :
    void listAdd(Node * &r, Node * p);//add p to r
    void listdelete(Node * p);
    void listUnion(Node * x, Node * y);//add x and y
    int Dn() {return (log2(n) + 1);} //当所有根都合并到一棵树上时，dn最大，为log2(n), 参考二项树
    void consolidate();
    void heapLink(Node * y, Node * x);
    void cut(Node * x, Node * y);
    void cascadingCut(Node * y);
    Node * search(Node * r, int k);//search is not good in heap
public :
    FibHeap() : min(nullptr), n(0) {}
    void insert(int k);
    int extractMin(); //get minimum node and delete it
    int minimum() {return min->key;}
    void decreaseKey(Node * x, int k);
    void remove(int k);
    void heapUnion(FibHeap &b);
    bool search(int k) {return (search(min, k) == nullptr ? false : true);}
    bool empty() {return n == 0;}
};

void FibHeap::listAdd(Node * &r, Node * p) {
    if (r == nullptr) {
        r = p;
        r->left = r;
        r->right = r;
    }
    else {
        Node * x = r; //去引用
        p->right = x->right;
        p->left = x;
        x->right->left = p;
        x->right = p;
    }
}

void FibHeap::listdelete(Node * p) {
    p->left->right = p->right;
    p->right->left = p->left;
}

void FibHeap::listUnion(Node * x, Node * y) {
    if (x == nullptr)
        x = y;
    else {
        Node * tail = x->left;
        x->left->right = y;
        y->left->right = x;
        x->left = y->left;
        y->left = tail;
    }
}

void FibHeap::insert(int k) {
    Node * p = new Node;
    p->key = k;
    listAdd(min, p);
    if (min->key > k) {
        min = p;
    }
    ++n;
}

void FibHeap::heapLink(Node * y, Node * x) {
    listdelete(y);
    listAdd(x->child, y);
    ++x->degree;
    y->mark = false;
}

void FibHeap::consolidate() {
    vector<Node*> a(Dn(), nullptr);
    Node *x, *y, *z;
    int d;
    Node * sentry = new Node;
    listAdd(min->left, sentry); //add a sentry
    for (x = min; x != sentry; x = z) {
        z = x->right; //防止x被link到y上，导致x-right无法指向正确的位置，所以先保存
        d = x->degree;
        while (a[d] != nullptr) {
            y = a[d];
            if (x->key > y->key)
                swap(x, y);
            heapLink(y, x);
            a[d] = nullptr;
            ++d;
        }
        a[d] = x;
    }
    min = nullptr;
    for (int i = 0; i < a.size(); ++i) {
        if (a[i] != nullptr) {
            listAdd(min, a[i]);
            if (a[i]->key < min->key)
                min = a[i];
        }
    }
    delete sentry;
}

int FibHeap::extractMin() {
    int ret = 0;
    Node * p = min;
    if (p) {
        ret = p->key;
        if (p->child) {
            Node * x = p->child;
            Node * y = x->right;
            for (int i = 0; i < p->degree; ++i) {
                listAdd(min, x);
                x->parent = nullptr;
                x = y;
                y = y->right;
            }
        }
        if (p->right == p) //the child of p is empty, and p is the only one in root list
            min = nullptr;
        else {
            min = p->right;
            listdelete(p);
            consolidate();
        }
        delete p;
        --n;
    }
    return ret;
}

void FibHeap::cut(Node * x, Node * y) {
    listdelete(x);
    --y->degree;
    listAdd(min, x);
    x->parent = nullptr;
    x->mark = false;
}

void FibHeap::cascadingCut(Node * y) {
    Node * z = y->parent;
    if (z) {
        if (y->mark == false)
            y->mark = true;
        else {
            cut(y, z);
            cascadingCut(z);
        }
    }
}

void FibHeap::decreaseKey(Node * x, int k) {
    if (k >= x->key)
        return ;
    x->key = k;
    Node * y = x->parent;
    if (y && y->key > x->key) {
        cut(x, y);
        cascadingCut(y);
    }
    if (x->key < min->key)
        min = x;
}

void FibHeap::remove(int k) {
    Node * p = search(min, k);
    if (p == nullptr)
        return ;
    decreaseKey(p, INT_MIN);
    extractMin();
}

void FibHeap::heapUnion(FibHeap &b) { //can't use b any more
    if (b.min == nullptr)
        return ;
    listUnion(min, b.min);
    if (min->key > b.min->key)
        min = b.min;
    n += b.n;
}

FibHeap::Node * FibHeap::search(Node * r, int k) {
    if (r == nullptr)
        return r;
    Node * x = r, *y;
    do {
        if (x->key == k)
            return x;
        else if (x->key < k) {
            y = search(x->child, k);
            if (y)
                return y;
        }
        x = x->right;
    } while (x != r);

    return nullptr;
}