算法导论斐波那契堆

最新推荐文章于 2022-02-15 01:26:55 发布
最新推荐文章于 2022-02-15 01:26:55 发布
阅读量378 收藏 2
点赞数 1
分类专栏： C++ 算法导论 文章标签： 算法导论 摊还算法 数据结构 
出处：http://www.cnblogs.com/skywang12345/p/3659069.html

#include <iomanip>
#include <iostream>
#include <cstdlib>
#include <cmath>

#define DEBUG 0

using namespace std;

template <class T>
class FibNode {
    public:
        T key;                // 关键字(键值)
        int degree;            // 度数
        FibNode<T> *left;    // 左兄弟
        FibNode<T> *right;    // 右兄弟
        FibNode<T> *child;    // 第一个孩子节点
        FibNode<T> *parent;    // 父节点
        bool marked;        // 是否被删除第一个孩子

        FibNode(T value):key(value), degree(0), marked(false), 
            left(NULL),right(NULL),child(NULL),parent(NULL) {
            key    = value;
            degree = 0;
            marked = false;
            left   = this;
            right  = this;
            parent = NULL;
            child  = NULL;
        }
};

template <class T>
class FibHeap {
    private:
        int keyNum;         // 堆中节点的总数
        int maxDegree;      // 最大度
        FibNode<T> *min;    // 最小节点(某个最小堆的根节点)
        FibNode<T> **cons;    // 最大度的内存区域

    public:
        FibHeap();
        ~FibHeap();

        // 新建key对应的节点，并将其插入到斐波那契堆中
        void insert(T key);
        // 移除斐波那契堆中的最小节点
        void removeMin();
        // 将other合并到当前堆中
        void combine(FibHeap<T> *other);
        // 获取斐波那契堆中最小键值，并保存到pkey中；成功返回true，否则返回false。
        bool minimum(T *pkey);
        // 将斐波那契堆中键值oldkey更新为newkey
        void update(T oldkey, T newkey);
        // 删除键值为key的节点
        void remove(T key);
        // 斐波那契堆中是否包含键值key
        bool contains(T key);
        // 打印斐波那契堆
        void print();
        // 销毁
        void destroy();

    private:
        // 将node从双链表移除
        void removeNode(FibNode<T> *node);
        // 将node堆结点加入root结点之前(循环链表中)
        void addNode(FibNode<T> *node, FibNode<T> *root);
        // 将双向链表b链接到双向链表a的后面
        void catList(FibNode<T> *a, FibNode<T> *b);
        // 将节点node插入到斐波那契堆中
        void insert(FibNode<T> *node);
        // 将"堆的最小结点"从根链表中移除，
        FibNode<T>* extractMin();
        // 将node链接到root根结点
        void link(FibNode<T>* node, FibNode<T>* root);
        // 创建consolidate所需空间
        void makeCons();
        // 合并斐波那契堆的根链表中左右相同度数的树
        void consolidate();
        // 修改度数
        void renewDegree(FibNode<T> *parent, int degree);
        // 将node从父节点parent的子链接中剥离出来，并使node成为"堆的根链表"中的一员。
        void cut(FibNode<T> *node, FibNode<T> *parent);
        // 对节点node进行"级联剪切"
        void cascadingCut(FibNode<T> *node) ;
        // 将斐波那契堆中节点node的值减少为key
        void decrease(FibNode<T> *node, T key);
        // 将斐波那契堆中节点node的值增加为key
        void increase(FibNode<T> *node, T key);
        // 更新斐波那契堆的节点node的键值为key
        void update(FibNode<T> *node, T key);
        // 在最小堆root中查找键值为key的节点
        FibNode<T>* search(FibNode<T> *root, T key);
        // 在斐波那契堆中查找键值为key的节点
        FibNode<T>* search(T key);
        // 删除结点node
        void remove(FibNode<T> *node);
        // 销毁斐波那契堆
        void destroyNode(FibNode<T> *node);
        // 打印"斐波那契堆"
        void print(FibNode<T> *node, FibNode<T> *prev, int direction);
};

/* 
 * 构造函数
 */
template <class T>
FibHeap<T>::FibHeap()
{
    keyNum = 0;
    maxDegree = 0;
    min = NULL;
    cons = NULL;
}

/* 
 * 析构函数
 */
template <class T>
FibHeap<T>::~FibHeap() 
{
}

/* 
 * 将node从双链表移除
 */
template <class T>
void FibHeap<T>::removeNode(FibNode<T> *node)
{
    node->left->right = node->right;
    node->right->left = node->left;
}
 
/*
 * 将node堆结点加入root结点之前(循环链表中)
 *   a …… root
 *   a …… node …… root
*/
template <class T>
void FibHeap<T>::addNode(FibNode<T> *node, FibNode<T> *root)
{
    node->left        = root->left;
    root->left->right = node;
    node->right       = root;
    root->left        = node;
}
 
/*
 * 将节点node插入到斐波那契堆中
 */
template <class T>
void FibHeap<T>::insert(FibNode<T> *node)
{
    if (keyNum == 0)
        min = node;
    else
       {
        addNode(node, min);
        if (node->key < min->key)
            min = node;
    }
    keyNum++;
}
 
/* 
 * 新建键值为key的节点，并将其插入到斐波那契堆中
 */
template <class T>
void FibHeap<T>::insert(T key)
{
    FibNode<T> *node;

    node = new FibNode<T>(key);
    if (node == NULL)
        return ;

    insert(node);
}

/*
 * 将双向链表b链接到双向链表a的后面
 *
 * 注意： 此处a和b都是双向链表
 */
template <class T>
void FibHeap<T>::catList(FibNode<T> *a, FibNode<T> *b)
{
    FibNode<T> *tmp;

    tmp            = a->right;
    a->right       = b->right;
    b->right->left = a;
    b->right       = tmp;
    tmp->left      = b;
}

  
/*
 * 将other合并到当前堆中
 */
template <class T>
void FibHeap<T>::combine(FibHeap<T> *other)
{
    if (other==NULL)
        return ;

    if(other->maxDegree > this->maxDegree)
        swap(*this, *other);

    if((this->min) == NULL)                // this无"最小节点"
    {
        this->min = other->min;
        this->keyNum = other->keyNum;
        free(other->cons);
        delete other;
    }
    else if((other->min) == NULL)           // this有"最小节点" && other无"最小节点"
    {
        free(other->cons);
        delete other;
    }                                       // this有"最小节点" && other有"最小节点"
    else
    {
        // 将"other中根链表"添加到"this"中
        catList(this->min, other->min);

        if (this->min->key > other->min->key)
            this->min = other->min;
        this->keyNum += other->keyNum;
        free(other->cons);
        delete other;
    }
}

/*
 * 将"堆的最小结点"从根链表中移除，
 * 这意味着"将最小节点所属的树"从堆中移除!
 */
template <class T>
FibNode<T>* FibHeap<T>::extractMin()
{
    FibNode<T> *p = min;

    if (p == p->right)
        min = NULL;
    else
    {
        removeNode(p);
        min = p->right;
    }
    p->left = p->right = p;

    return p;
}
 
/*
 * 将node链接到root根结点
 */
template <class T>
void FibHeap<T>::link(FibNode<T>* node, FibNode<T>* root)
{
    // 将node从双链表中移除
    removeNode(node);
    // 将node设为root的孩子
    if (root->child == NULL)
        root->child = node;
    else
        addNode(node, root->child);

    node->parent = root;
    root->degree++;
    node->marked = false;
}
 
/* 
 * 创建consolidate所需空间
 */
template <class T>
void FibHeap<T>::makeCons()
{
    int old = maxDegree;

    // 计算log2(keyNum)，"+1"意味着向上取整！
    // ex. log2(13) = 3，向上取整为3+1=4。
    maxDegree = (log(keyNum)/log(2.0)) + 1;
    if (old >= maxDegree)
        return ;

    // 因为度为maxDegree可能被合并，所以要maxDegree+1
    cons = (FibNode<T> **)realloc(cons, 
            sizeof(FibHeap<T> *) * (maxDegree + 1));
}

/* 
 * 合并斐波那契堆的根链表中左右相同度数的树
 */
template <class T>
void FibHeap<T>::consolidate()
{
    int i, d, D;
    FibNode<T> *x, *y, *tmp;

    makeCons();//开辟哈希所用空间
    D = maxDegree + 1;

    for (i = 0; i < D; i++)
        cons[i] = NULL;
 
    // 合并相同度的根节点，使每个度数的树唯一
    while (min != NULL)
    {
        x = extractMin();                // 取出堆中的最小树(最小节点所在的树)
        d = x->degree;                    // 获取最小树的度数
        // cons[d] != NULL，意味着有两棵树(x和y)的"度数"相同。
        while (cons[d] != NULL)
        {
            y = cons[d];                // y是"与x的度数相同的树" 
            if (x->key > y->key)        // 保证x的键值比y小
                swap(x, y);

            link(y, x);    // 将y链接到x中
            cons[d] = NULL;
            d++;
        }
        cons[d] = x;
    }
    min = NULL;
 
    // 将cons中的结点重新加到根表中
    for (i=0; i<D; i++)
    {
        if (cons[i] != NULL)
        {
            if (min == NULL)
                min = cons[i];
            else
            {
                addNode(cons[i], min);
                if ((cons[i])->key < min->key)
                    min = cons[i];
            }
        }
    }
}
 
/*
 * 移除最小节点
 */
template <class T>
void FibHeap<T>::removeMin()
{
    if (min==NULL)
        return ;

    FibNode<T> *child = NULL;
    FibNode<T> *m = min;
    // 将min每一个儿子(儿子和儿子的兄弟)都添加到"斐波那契堆的根链表"中
    while (m->child != NULL)
    {
        child = m->child;
        removeNode(child);
        if (child->right == child)
            m->child = NULL;
        else
            m->child = child->right;

        addNode(child, min);
        child->parent = NULL;
    }

    // 将m从根链表中移除
    removeNode(m);
    // 若m是堆中唯一节点，则设置堆的最小节点为NULL；
    // 否则，设置堆的最小节点为一个非空节点(m->right)，然后再进行调节。
    if (m->right == m)
        min = NULL;
    else
    {
        min = m->right;
        consolidate();
    }
    keyNum--;

    delete m;
}

/*
 * 获取斐波那契堆中最小键值，并保存到pkey中；成功返回true，否则返回false。
 */
template <class T>
bool FibHeap<T>::minimum(T *pkey)
{
    if (min==NULL || pkey==NULL)
        return false;

    *pkey = min->key;
    return true;
}
  
/* 
 * 修改度数
 */
template <class T>
void FibHeap<T>::renewDegree(FibNode<T> *parent, int degree)
{
    parent->degree -= degree;
    if (parent-> parent != NULL)
        renewDegree(parent->parent, degree);
}
 
/* 
 * 将node从父节点parent的子链接中剥离出来，
 * 并使node成为"堆的根链表"中的一员。
 */
template <class T>
void FibHeap<T>::cut(FibNode<T> *node, FibNode<T> *parent)
{
    removeNode(node);
    renewDegree(parent, node->degree);
    // node没有兄弟
    if (node == node->right) 
        parent->child = NULL;
    else 
        parent->child = node->right;

    node->parent = NULL;
    node->left = node->right = node;
    node->marked = false;
    // 将"node所在树"添加到"根链表"中
    addNode(node, min);
}

/* 
 * 对节点node进行"级联剪切"
 *
 * 级联剪切：如果减小后的结点破坏了最小堆性质，
 *     则把它切下来(即从所在双向链表中删除，并将
 *     其插入到由最小树根节点形成的双向链表中)，
 *     然后再从"被切节点的父节点"到所在树根节点递归执行级联剪枝
 */
template <class T>
void FibHeap<T>::cascadingCut(FibNode<T> *node) 
{
    FibNode<T> *parent = node->parent;
    if (parent != NULL)
    {
        if (node->marked == false) 
            node->marked = true;
        else
        {
            cut(node, parent);
            cascadingCut(parent);
        }
    }
}

/* 
 * 将斐波那契堆中节点node的值减少为key
 */
template <class T>
void FibHeap<T>::decrease(FibNode<T> *node, T key)
{
    FibNode<T> *parent;

    if (min==NULL ||node==NULL) 
        return ;

    if ( key>=node->key)
    {
        cout << "decrease failed: the new key(" << key <<") "
             << "is no smaller than current key(" << node->key <<")" << endl;
        return ;
    }

    node->key = key;
    parent = node->parent;
    if (parent!=NULL && node->key < parent->key)
    {
        // 将node从父节点parent中剥离出来，并将node添加到根链表中
        cut(node, parent);
        cascadingCut(parent);
    }

    // 更新最小节点
    if (node->key < min->key)
        min = node;
}

/* 
 * 将斐波那契堆中节点node的值增加为key
 */
template <class T>
void FibHeap<T>::increase(FibNode<T> *node, T key)
{
    FibNode<T> *child, *parent, *right;

    if (min==NULL ||node==NULL) 
        return ;

    if (key <= node->key)
    {
        cout << "increase failed: the new key(" << key <<") " 
             << "is no greater than current key(" << node->key <<")" << endl;
        return ;
    }

    // 将node每一个儿子(不包括孙子,重孙,...)都添加到"斐波那契堆的根链表"中
    while (node->child != NULL)
    {
        child = node->child;
        removeNode(child);               // 将child从node的子链表中删除
        if (child->right == child)
            node->child = NULL;
        else
            node->child = child->right;

        addNode(child, min);       // 将child添加到根链表中
        child->parent = NULL;
    }
    node->degree = 0;
    node->key = key;

    // 如果node不在根链表中，
    //     则将node从父节点parent的子链接中剥离出来，
    //     并使node成为"堆的根链表"中的一员，
    //     然后进行"级联剪切"
    // 否则，则判断是否需要更新堆的最小节点
    parent = node->parent;
    if(parent != NULL)
    {
        cut(node, parent);
        cascadingCut(parent);
    }
    else if(min == node)
    {
        right = node->right;
        while(right != node)
        {
            if(node->key > right->key)
                min = right;
            right = right->right;
        }
    }
}

/* 
 * 更新斐波那契堆的节点node的键值为key
 */
template <class T>
void FibHeap<T>::update(FibNode<T> *node, T key)
{
    if(key < node->key)
        decrease(node, key);
    else if(key > node->key)
        increase(node, key);
    else
        cout << "No need to update!!!" << endl;
}
  
template <class T>
void FibHeap<T>::update(T oldkey, T newkey)
{
    FibNode<T> *node;

    node = search(oldkey);
    if (node!=NULL)
        update(node, newkey);
}

/*
 * 在最小堆root中查找键值为key的节点
 */
template <class T>
FibNode<T>* FibHeap<T>::search(FibNode<T> *root, T key)
{
    FibNode<T> *t = root;    // 临时节点
    FibNode<T> *p = NULL;    // 要查找的节点

    if (root==NULL)
        return root;

    do
    {
        if (t->key == key)
        {
            p = t;
            break;
        } 
        else
        {
            if ((p = search(t->child, key)) != NULL) 
                break;
        }    
        t = t->right;
    } while (t != root);

    return p;
}
 
/*
 * 在斐波那契堆中查找键值为key的节点
 */
template <class T>
FibNode<T>* FibHeap<T>::search(T key)
{
    if (min==NULL)
        return NULL;

    return search(min, key);
}

/*
 * 在斐波那契堆中是否存在键值为key的节点。
 * 存在返回true，否则返回false。
 */
template <class T>
bool FibHeap<T>::contains(T key)
{
    return search(key)!=NULL ? true: false;
}

/*
 * 删除结点node
 */
template <class T>
void FibHeap<T>::remove(FibNode<T> *node)
{
    T m = min->key-1;
    decrease(node, m-1);
    removeMin();
}

template <class T>
void FibHeap<T>::remove(T key)
{
    FibNode<T> *node;

    if (min==NULL)
        return ;

    node = search(key);
    if (node==NULL)
        return ;

    remove(node);
}
 
/* 
 * 销毁斐波那契堆
 */
template <class T>
void FibHeap<T>::destroyNode(FibNode<T> *node)
{
    FibNode<T> *start = node;

    if(node == NULL)
        return;

    do {
        destroyNode(node->child);
        // 销毁node，并将node指向下一个
        node = node->right;
        delete node->left;
    } while(node != start);
}
 
template <class T>
void FibHeap<T>::destroy()
{
    destroyNode(min);
    free(cons);
}

/*
 * 打印"斐波那契堆"
 *
 * 参数说明：
 *     node       -- 当前节点
 *     prev       -- 当前节点的前一个节点(父节点or兄弟节点)
 *     direction  --  1，表示当前节点是一个左孩子;
 *                    2，表示当前节点是一个兄弟节点。
 */
template <class T>
void FibHeap<T>::print(FibNode<T> *node, FibNode<T> *prev, int direction)
{
    FibNode<T> *start=node;

    if (node==NULL)
        return ;
    do
    {
        if (direction == 1)
            cout << setw(8) << node->key << "(" << node->degree << ") is "<< setw(2) << prev->key << "'s child" << endl;
        else
            cout << setw(8) << node->key << "(" << node->degree << ") is "<< setw(2) << prev->key << "'s next" << endl;

        if (node->child != NULL)
            print(node->child, node, 1);

        // 兄弟节点
        prev = node;
        node = node->right;
        direction = 2;
    } while(node != start);
}

template <class T>
void FibHeap<T>::print()
{
    int i=0;
    FibNode<T> *p;

    if (min==NULL)
        return ;

    cout << "== 斐波那契堆的详细信息: ==" << endl;
    p = min;
    do {
        i++;
        cout << setw(2) << i << ". " << setw(4) << p->key << "(" << p->degree << ") is root" << endl;

        print(p->child, p, 1);
        p = p->right;
    } while (p != min);
    cout << endl;
}



// 共8个,验证信息数组 
int a[] = {12,  7, 25, 15, 28, 
           33, 41,  1};
// 共14个
int b[] = {18, 35, 20, 42,  9, 
           31, 23,  6, 48, 11, 
           24, 52, 13,  2};
           
           

// 验证"基本信息(斐波那契堆的结构)"
void testBasic()
{
    int i;
    int blen=sizeof(b)/sizeof(b[0]);
    FibHeap<int>* hb=new FibHeap<int>();

    // 斐波那契堆hb
    cout << "== 斐波那契堆(hb)中依次添加: ";
    for(i=0; i<blen; i++)
    {
        cout << b[i] <<" ";
        hb->insert(b[i]);
    }
    cout << endl;
    cout << "== 斐波那契堆(hb)删除最小节点" << endl;
    hb->removeMin();
    hb->print();
}

// 验证"插入操作"
void testInsert()
{
    int i;
    int alen=sizeof(a)/sizeof(a[0]);
    FibHeap<int>* ha=new FibHeap<int>();

    cout << "== 斐波那契堆(ha)中依次添加: ";
    for(i=0; i<alen; i++)
    {
        cout << a[i] <<" ";
        ha->insert(a[i]);
    }
    cout << endl;
    cout << "== 斐波那契堆(ha)删除最小节点" << endl;
    ha->removeMin();
    ha->print();

    // 斐波那契堆hb
    cout << "== 插入50" << endl;
    ha->insert(50);
    ha->print();
}

// 验证"合并操作"
void testUnion()
{
    int i;
    int alen=sizeof(a)/sizeof(a[0]);
    int blen=sizeof(b)/sizeof(b[0]);
    FibHeap<int>* ha=new FibHeap<int>();
    FibHeap<int>* hb=new FibHeap<int>();

    cout << "== 斐波那契堆(ha)中依次添加: ";
    for(i=0; i<alen; i++)
    {
        cout << a[i] <<" ";
        ha->insert(a[i]);
    }
    cout << endl;
    cout << "== 斐波那契堆(ha)删除最小节点" << endl;
    ha->removeMin();
    ha->print();

    // 斐波那契堆hb
    cout << "== 斐波那契堆(hb)中依次添加: ";
    for(i=0; i<blen; i++)
    {
        cout << b[i] <<" ";
        hb->insert(b[i]);
    }
    cout << endl;
    cout << "== 斐波那契堆(hb)删除最小节点" << endl;
    hb->removeMin();
    hb->print();

    // 将"斐波那契堆hb"合并到"斐波那契堆ha"中。
    cout << "== 合并ha和hb" << endl;
    ha->combine(hb);
    ha->print();
}

// 验证"删除最小节点"
void testRemoveMin()
{
    int i;
    int alen=sizeof(a)/sizeof(a[0]);
    int blen=sizeof(b)/sizeof(b[0]);
    FibHeap<int>* ha=new FibHeap<int>();
    FibHeap<int>* hb=new FibHeap<int>();

    cout << "== 斐波那契堆(ha)中依次添加: ";
    for(i=0; i<alen; i++)
    {
        cout << a[i] <<" ";
        ha->insert(a[i]);
    }
    cout << endl;
    cout << "== 斐波那契堆(ha)删除最小节点" << endl;
    ha->removeMin();
    //ha->print();

    // 斐波那契堆hb
    cout << "== 斐波那契堆(hb)中依次添加: ";
    for(i=0; i<blen; i++)
    {
        cout << b[i] <<" ";
        hb->insert(b[i]);
    }
    cout << endl;
    cout << "== 斐波那契堆(hb)删除最小节点" << endl;
    hb->removeMin();
    //hb->print();

    // 将"斐波那契堆hb"合并到"斐波那契堆ha"中。
    cout << "== 合并ha和hb" << endl;
    ha->combine(hb);
    ha->print();


    cout << "== 删除最小节点" << endl;
    ha->removeMin();
    ha->print();
}

// 验证"减小节点"
void testDecrease()
{
    int i;
    int blen=sizeof(b)/sizeof(b[0]);
    FibHeap<int>* hb=new FibHeap<int>();

    // 斐波那契堆hb
    cout << "== 斐波那契堆(hb)中依次添加: ";
    for(i=0; i<blen; i++)
    {
        cout << b[i] <<" ";
        hb->insert(b[i]);
    }
    cout << endl;
    cout << "== 斐波那契堆(hb)删除最小节点" << endl;
    hb->removeMin();
    hb->print();

    cout << "== 将20减小为2" << endl;
    hb->update(20, 2);
    hb->print();
}

// 验证"增大节点"
void testIncrease()
{
    int i;
    int blen=sizeof(b)/sizeof(b[0]);
    FibHeap<int>* hb=new FibHeap<int>();

    // 斐波那契堆hb
    cout << "== 斐波那契堆(hb)中依次添加: ";
    for(i=0; i<blen; i++)
    {
        cout << b[i] <<" ";
        hb->insert(b[i]);
    }
    cout << endl;
    cout << "== 斐波那契堆(hb)删除最小节点" << endl;
    hb->removeMin();
    hb->print();

    cout << "== 将20增加为60" << endl;
    hb->update(20, 60);
    hb->print();
}

// 验证"删除节点"
void testDelete()
{
    int i;
    int blen=sizeof(b)/sizeof(b[0]);
    FibHeap<int>* hb=new FibHeap<int>();

    // 斐波那契堆hb
    cout << "== 斐波那契堆(hb)中依次添加: ";
    for(i=0; i<blen; i++)
    {
        cout << b[i] <<" ";
        hb->insert(b[i]);
    }
    cout << endl;
    cout << "== 斐波那契堆(hb)删除最小节点" << endl;
    hb->removeMin();
    hb->print();

    cout << "== 删除节点20" << endl;
    hb->remove(20);
    hb->print();
}


int main()
{
	
    // 验证"基本信息(斐波那契堆的结构)"
    testBasic();
    // 验证"插入操作"
    //testInsert();
    // 验证"合并操作"
    //testUnion();
    // 验证"删除最小节点"
    //testRemoveMin();
    // 验证"减小节点"
    //testDecrease();
    // 验证"增大节点"
    //testIncrease();
    // 验证"删除节点"
    //testDelete();

    return 0;
}

coolsunxu
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
dijkstra算法的三种实现：数组，二叉堆，斐波那契堆 + 部分实验报告
01-12
dijkstra算法的三种实现：数组，二叉堆，斐波那契堆 + 部分实验报告 dijkstra算法的三种实现：数组，二叉堆，斐波那契堆 + 部分实验报告 dijkstra算法的三种实现：数组，二叉堆，斐波那契堆 + 部分实验报告
斐波那契堆(一)之 图文解析 和 C语言的实现
xiedeacc的专栏
06-01 1535
斐波那契堆(一)之 图文解析 和 C语言的实现   概要 本章介绍斐波那契堆。和以往一样，本文会先对斐波那契堆的理论知识进行简单介绍，然后给出C语言的实现。后续再分别给出C++和Java版本的实现；实现的语言虽不同，但是原理如出一辙，选择其中之一进行了解即可。若文章有错误或不足的地方，请不吝指出！ 目录 1. 斐波那契堆的介绍 2. 斐波那契堆的基本操作 3. 斐波那契堆
斐波那契堆的C++实现
Castria的博客
02-15 2501
本文改编自《算法导论》第三版第19章：斐波那契堆。
斐波那契堆
└┼﹡keep it simple,stupid■┐＊…
12-07 367
介绍斐波那契堆支持二叉堆上的基本操作并且插入和增加key值的速度相对较快。它是由多颗树组合而成的，而每颗树的根结点组合成的链表叫根链表，是一个双向的循环链表。它有一个指向树中最小结点的指针以及保存了一个树中的结点数量。每个结点可以有n个孩子组合成的双向循环链表，但是只能指向其中的某一个孩子，每个结点的孩子数量称为degree；每个结点还有一个mark属性，用来表示自从此结点有孩子以及是否丢...
斐波那契堆：基于标准计算机科学教科书的斐波那契堆实现。-matlab开发
06-01
这个斐波那契堆实现是在 MATLAB 中开发的，用于一般用途，但其特定目的是稍后与“Matlog”使用的 Dijkstra 算法实现集成。 有关更多详细信息，请参阅 README.pdf 文件。 要创建一个名为 myHeap 的堆，应该执行以下 MATLAB 命令：myHeap=cFibHeap。 可以使用命令 myHeap.insert(num) 将键（值）插入到堆中，其中要插入的键是 num。 命令 myHeap.findMin 返回最小键，命令 myHeap.extractMin 返回并删除最小键。 堆的大小（节点总数）可以通过命令 myHeap.n 确定。 操作 Insert、Find-Min 和 Extract-Min 是测试版中唯一支持的操作。 未来版本将支持以下标准堆操作：Merge-Heaps、Increase-Key 和 Decrease-Key。
斐波那契堆C++实现
04-27
斐波那契堆C++实现，有详细注释
算法导论斐波那契堆（C#,C++）
10-15
在《算法导论》一书中，斐波那契堆被广泛讨论，因为它在解决诸如最短路径、最小生成树等算法问题时能提供高效的性能。下面我们将深入探讨斐波那契堆的原理、实现方式以及C#和C++中的应用。 斐波那契堆是由若干个堆...
算法导论.rar
05-07
《算法导论》是计算机科学领域的一本经典著作，它由Thomas H. Cormen、Charles E. Leiserson、Ronald L. Rivest和Clifford Stein四位作者共同撰写，全面深入地探讨了算法的设计、分析及实现。这本书的第三版更加完善...
算法导论_算法导论_
10-03
《算法导论》是一本深度探讨算法理论与实践的经典著作，旨在揭示算法的本质，帮助读者理解和掌握算法的设计、分析以及应用。算法是计算机科学的核心，是解决复杂问题的有效工具，对于提升程序性能、优化资源利用等...
算法导论第三版答案_算法导论_
09-29
《算法导论》是计算机科学领域的一本经典之作，它深入浅出地介绍了算法的设计、分析和实现。这本书对于Python编程者来说，尤其有价值，因为它不仅涵盖了基础算法，还涉及了高级算法技巧，有助于提升编程者的问题解决...
算法设计与分析——斐波那契堆
jmhIcoding
11-10 7574
引言 这章，我们来看看大名鼎鼎的斐波那契堆。这个堆就很有意思了，居然能和大名鼎鼎的斐波那契数列挂上边。
图
mysunnnyday的专栏
07-19 497
#ifndef __BASE_H__ #define __BASE_H__ #include #include "binomial heap.h" using namespace std; /*********************************stack**********************************/ template class stack { public
斐波那契堆——算法导论(26)
dayin201608的博客
10-03 659
1. 写在前面 在很久之前学习过堆这种数据结构。这次再来学习一种比较特别的“堆”——斐波那契堆。下文首先会介绍斐波那契堆的结构，然后会介绍在其上的操作，最后再分析这些操作的效率，以及一些理论的证明。 2. 结构 斐波那契堆是一系列具有最小堆序的有根树的集合，即斐波那契堆中的每棵树均遵循最小堆性质。 所谓最小堆性质是指：树中的每个结点的关键字大于或等于它的父结点（若存在）的关键字。具有最...
斐波那契堆的实现--python
ailinyingai的博客
09-03 523
class FibNode: def __init__(self, key): self.key = key self.degree = 0 self.p = 0 self.child = 0 self.left =0 self.right = 0 self.mark = Fa...
结构之美——优先队列三大结构（二）——斐波那契堆（Fibonacci Heap）
小熊不去实验室
11-05 9013
1.简介 斐波那契堆是一种松散的二项堆，与二项堆的主要区别在于构成斐波那契堆得树可以不是二项树，并且这些树的根排列是无序的（二项堆的根结点排序从左到右是按照结点个数排序的，不是按照根结点的大小）。 斐波那契堆得优势在于它对建堆、插入、抽取最小关键字、联合等操作能在O(1)的时间内完成（不涉及删除元素的操作仅需要O（1））。这是对二项堆效率的巨大改善。在EXACT-MIN|, DELETE的操作
《算法导论3rd第十九章》斐波那契堆
懒猫的脚印
12-13 1101
算法导论，第十九章，斐波那契堆，二叉堆，二项堆
算法导论之斐波那契堆
医疗影像检索
08-05 4172
斐波那契堆，和二项堆类似，也是由一组最小堆有序的树构成。注意区别，不是二项树，是有根而无序的树。导论中，斐波那契堆只是具有理论上的意义，是以平摊分析为指导思想来设计的数据结构，主要是渐进时间界比二项堆有改善。斐波那契堆除去删除元素操作外，其他操作只有O(1)的平摊运行时间，而二项堆需要O(lgn)的最坏情况运行时间。但若要斐波那契堆能转化为实际应用，除要保证有相同平摊时间界限外，还需更简单的数据结
斐波那契堆(Fibonacci heap)原理详解(附java代码实现)
weixin_30399871的博客
06-06 579
前言 　　斐波那契堆(Fibonacci heap)是计算机科学中最小堆有序树的集合。它和二项式堆有类似的性质，但比二项式堆有更好的均摊时间。堆的名字来源于斐波那契数，它常用于分析运行时间。 堆结构介绍 　　基本术语介绍： 　　关键字：堆节点储存的用于比较的信息 　　度数：堆节点拥有的孩子数(注意，不包括孩子的孩子) 　　左兄弟：节点左边的兄弟节点 ...
FibonacciHeaps-2x2.pdf
11-28
"这篇文档是关于Fibonacci堆的算法设计，主要涵盖了Fibonacci堆的基本操作，包括插入、删除最小元素、降低键值、排名限制、合并与删除的操作，并对比了不同数据结构如链表、二叉堆、二项堆在执行这些操作时的时间...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值