二项堆

最新推荐文章于 2022-02-18 14:22:28 发布
原创 最新推荐文章于 2022-02-18 14:22:28 发布 · 243 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 

/*******************************************************
  基本思想：应用二项堆的性质：
            1.H中每个二项树遵循最小堆性质（结点的关键字最小）
            2.任意non-negative k，H中至多有以可二项树的根的度数为k（度数唯一）

  建堆时，对于单个节点，malloc结点度都是0，直接按照前后关系链接，然后根据键值进行吞并
          对于含堆情况，根据度的情况进行非递减链接
                         然后根据度的重合情况以及键值进行吞并，注意吞并过程需要修改degree

********************************************************/
#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<climits>
using namespace std;

typedef struct BinHeapNode BinNode;
typedef struct BinHeapNode * BinHeap;
typedef struct BinHeapNode * Position;

//结点ADT
struct BinHeapNode
{
    int key;
    int degree;
    Position parent;
    Position leftChild;
    Position sibling;
};

//用数组内的值建堆
BinHeap MakeBinHeapWithArray(int keys[], int n);

//两个堆合并
BinHeap BinHeapUnion(BinHeap &H1, BinHeap &H2);

//将H1, H2的根表合并成一个按度数的单调递增次序排列的链表
BinHeap BinHeapMerge(BinHeap &H1, BinHeap &H2);

//使H2成为H1的父节点
void BinLink(BinHeap &H1, BinHeap &H2);

//返回最小根节点的指针
BinHeap BinHeapMin(BinHeap heap);

//减少关键字的值
void BinHeapDecreaseKey(BinHeap heap, BinHeap x, int key);

//删除一个关键字
BinHeap BinHeapDelete(BinHeap &heap, int key);

//找出一个关键字
BinHeap BinHeapFind(BinHeap &heap, int key);

//打印输出堆结构
void PrintBinHeap(BinHeap heap);

//插入一个节点
BinHeap BinHeapInsert(BinHeap heap,int key);

//销毁堆
void DestroyBinHeap(BinHeap &heap);

//用数组内的值建堆
BinHeap MakeBinHeapWithArray(int keys[], int n)
{
    BinHeap heap = NULL, newHeap = NULL;
    for (int i = 0; i < n; i++)
    {

        newHeap = (BinHeap) malloc(sizeof(BinNode));
        if (newHeap == NULL)
        {
            puts("Out of the Space");
            exit(1);
        }
        memset(newHeap, 0, sizeof(BinNode));
        newHeap->key = keys[i];
        if (NULL == heap)
        {
            heap = newHeap;
        }
        else
        {
            heap = BinHeapUnion(heap, newHeap);
            newHeap = NULL;
        }

    }
    return heap;
}

//两个堆合并
BinHeap BinHeapUnion(BinHeap &H1, BinHeap &H2)
{
    Position heap = NULL, pre_x = NULL, x = NULL, next_x = NULL;
    heap = BinHeapMerge(H1, H2);
    if (heap == NULL)
    {
        return heap;
    }

    x = heap;
    next_x = x->sibling;

    while (next_x != NULL)                      //Cases 1 and 2
    {
        if ((x->degree != next_x->degree) ||
                ((next_x->sibling != NULL) && (next_x->degree == next_x->sibling->degree)))
        {
            pre_x = x;
            x = next_x;  //转127行
        }
        else if (x->key <= next_x->key)
        {
                                                /**************************************
                                                Cases 3  ，度相等，可以合并
                                                把结点键值大的放到下面去，成为键值小的的子树
                                                **************************************/
            x->sibling = next_x->sibling;
            BinLink(next_x, x);
        }
        else                             //Cases 4后面的更小
        {
            if (pre_x == NULL)
            {
                heap = next_x;
            }

            else
            {
                pre_x->sibling = next_x;//因为x要放到nextx下面去了，所以prex的右兄弟是nextx
            }

            BinLink(x, next_x);    //与109行功能相同，放较大值在下面
            x = next_x;
        }

        next_x = x->sibling;
    }
    return heap;
}                                  /*****************************************
                                    Case1表示x和nextx度不相等，不合并，则prex和nextx后移
                                    Case2表示x和nextx和nextnextx度相等，也是后移，这次不合并，但下次迭代一定合并
                                    Case3和Case4表示仅有x和nextx度相等，则发生合并
                                    Case3是前面的吞并后面的
                                    Case4是后面的吞并前面的
                                    1.度相等且pre没操作过，则heap需要改变
                                    2.度相等且pre操作过了，heap不需要改变
                                   *****************************************/


                                                              //将H1, H2的根表合并成一个按度数的单调递增次序排列的链表
BinHeap BinHeapMerge(BinHeap &H1, BinHeap &H2)
{
                                                              //heap返回堆的首地址，H3为指向新堆根结点
    BinHeap heap = NULL, firstHeap = NULL, secondHeap = NULL,
            pre_H3 = NULL, H3 = NULL;

    if (H1 != NULL && H2 != NULL)
    {
        firstHeap = H1;
        secondHeap = H2;
                                                             //整个while，firstHeap, secondHeap, pre_H3, H3都在往后顺移
        while (firstHeap != NULL && secondHeap != NULL)
        {
            if (firstHeap->degree <= secondHeap->degree)
            {
                H3 = firstHeap;                              //H3标记当前度更小的是first，并往后挪至其右兄弟
                                                            //同时度更小的树也往后挪
                firstHeap = firstHeap->sibling;
            }

            else
            {
                H3 = secondHeap;                             //H3标记当前度更小的是second，并往后挪至其右兄弟
                                                             //同时度更小的树也往后挪
                secondHeap = secondHeap->sibling;
            }

            if (pre_H3 == NULL)        //只有在首次比较度时才会用到
            {
                pre_H3 = H3;
                heap = H3;             //heap记录的是首次比较中得到的度最小的节点
            }
            else
            {
                pre_H3->sibling = H3;
                pre_H3 = H3;         /***************************************************************
                                      pre_H3是上一次比较中degree更小的结点，放在第一位（relatively）
                                      H3    是这一次比较中degree更小的结点，放在第二位（relatively）
                                      现在进行链接，第一位的右兄弟是现在的第二位
                                      并将pre_H3更新为现在得到的H3
                                     ****************************************************************/


            }
            if (firstHeap != NULL)
            {
                H3->sibling = firstHeap;
            }
            else
            {
                H3->sibling = secondHeap;
            }

        }   //ENDwhile

    }
    else if (H1 != NULL)
    {
        heap = H1;
    }
    else
    {
        heap = H2;
    }
    H1 = H2 = NULL;
    return heap;
}

//使H2成为H1的父节点
void BinLink(BinHeap &H1, BinHeap &H2)
{
    H1->parent = H2;
    H1->sibling = H2->leftChild;
    H2->leftChild = H1;
    H2->degree++;
}

//返回最小根节点的指针
BinHeap BinHeapMin(BinHeap heap)
{
    Position y = NULL, x = heap;
    int min = INT_MAX;

    while (x != NULL)
    {
        if (x->key < min)
        {
            min = x->key;
            y = x;
        }
        x = x->sibling;
    }
    return y;
}

//抽取有最小关键字的结点
BinHeap BinHeapExtractMin(BinHeap &heap)
{
    BinHeap pre_y = NULL, y = NULL, x = heap;
    int min = INT_MAX;
    while (x != NULL)
    {
        if (x->key < min)
        {
            min = x->key;
            pre_y = y;
            y = x;
        }
        x = x->sibling;
    }

    if (y == NULL)       //树为空
    {
        return NULL;
    }

    if (pre_y == NULL)   //最小值就是第一个根节点
    {
        heap = heap->sibling;
    }
    else
    {
        pre_y->sibling = y->sibling;
    }

    //将y的子结点指针reverse
    BinHeap H2 = NULL, p = NULL;
    x = y->leftChild;
    while (x != NULL)
    {
        p = x;
        x = x->sibling;
        p->sibling = H2;
        H2 = p;
        p->parent = NULL;
    }

    heap = BinHeapUnion(heap, H2);/********************************************
                                  在所有根节点访问一遍，找到最小值；
                                  将最小值的左兄弟（自定义）和右兄弟相连接(相当于删除)
                                  将此二项树剩余的子树自左向右链接
                                  将此剩余树和原树合并
                                  ********************************************/
    return y;
}

//插入一个结点
BinHeap BinHeapInsert(BinHeap heap,int key){
    BinHeap newHeap=NULL;
    newHeap=(BinHeap)malloc(sizeof(BinNode));

    if(newHeap == NULL){
        puts("Out of the Space!");
        exit(1);
    }
    memset(newHeap,0,sizeof(BinNode));
    newHeap->key=key;
    heap = BinHeapUnion(heap,newHeap);
    newHeap = NULL;
    return heap;
}

//减少关键字的值
void BinHeapDecreaseKey(BinHeap heap, BinHeap x, int key)
{
    if(key > x->key)
    {
        puts("new key is greaer than current key");
        exit(1); //不为降键
    }
    x->key = key;

    BinHeap z = NULL, y = NULL;
    y = x;
    z = x->parent;
    while(z != NULL && z->key > y->key)
    {
        swap(z->key, y->key);
        y = z;
        z = y->parent;
    }
}

//删除一个关键字
BinHeap BinHeapDelete(BinHeap &heap, int key)
{
    BinHeap x = NULL;
    x = BinHeapFind(heap, key);
    if (x != NULL)
    {
        BinHeapDecreaseKey(heap, x, INT_MIN);
        return BinHeapExtractMin(heap);
    }
    return x;
}

//找出一个关键字
BinHeap BinHeapFind(BinHeap &heap, int key)
{
    Position p = NULL, x = NULL;
    p = heap;
    while (p != NULL)
    {
        if (p->key == key)
        {
            return p;
        }
        else
        {
            if((x =BinHeapFind(p->leftChild, key)) != NULL)
            {
                return x;
            }
            p = p->sibling;
        }
    }
    return NULL;
}

//打印输出堆结构
void PrintBinHeap(BinHeap heap)
{
    if (NULL == heap)
    {
        return ;
    }
    Position p = heap;

    while (p != NULL)
    {
        printf(" (");
        printf("%d", p->key);
        //显示其孩子
        if(NULL != p->leftChild)
        {
            PrintBinHeap(p->leftChild);
        }
        printf(") ");

        p = p->sibling;
    }
}

int kp1[7] = {12,
              7, 25,
              15, 28, 33, 41
             };

int kp2[19] = {18,
               3, 37,
               6, 8, 29, 10, 44, 30, 23, 2, 48, 31, 17, 45, 32, 24, 50, 55
              };

int kp4[22] = {37, 41,
               10, 28, 13, 77,
               1, 6, 16, 12, 25, 8, 14, 29, 26, 23, 18, 11, 17, 38, 42, 27
              };

int kp5[5]={1,
            3,5,7,9,};


int main()
{
    printf("\nMutually Independent Parentheses Indicate that They are Siblings\n\nIn Each Parenthese, the first value is the root ,second is its leftchild, third one is its rightchild\n\n");
    BinHeap H1 = NULL;
    H1 = MakeBinHeapWithArray(kp1, sizeof(kp1)/sizeof(int));
    puts("第一个二叉堆H1:");
    PrintBinHeap(H1);


    BinHeap H5 = NULL;
    H5 = MakeBinHeapWithArray(kp5, sizeof(kp5)/sizeof(int));
    puts("\n\n第二个二叉堆H5:");
    PrintBinHeap(H5);

    BinHeap H3 = NULL;
    H3 = BinHeapUnion(H1, H5);
    puts("\n\n合并H1,H5后，得到H3:");
    PrintBinHeap(H3);

    BinHeap H6=NULL;
    H6=BinHeapInsert(H3,8);
    puts("\n\n插入数值8后，得到H6:");
    PrintBinHeap(H6);

    BinHeap H4 = NULL;
    H4 = MakeBinHeapWithArray(kp4, sizeof(kp4)/sizeof(int));
    puts("\n\n用于测试提取和删除的二叉堆H4:");
    PrintBinHeap(H4);

    BinHeap extractNode = BinHeapExtractMin(H4);
    if (extractNode != NULL)
    {
        printf("\n\n抽取最小的值%d后：\n", extractNode->key);
        PrintBinHeap(H4);
    }

    extractNode = BinHeapExtractMin(H4);
    if (extractNode != NULL)
    {
        printf("\n\n抽取最小的值%d后：\n", extractNode->key);
        PrintBinHeap(H4);
    }

    extractNode = BinHeapExtractMin(H4);
    if (extractNode != NULL)
    {
        printf("\n\n抽取最小的值%d后：\n", extractNode->key);
        PrintBinHeap(H4);
    }

    BinHeapDelete(H4, 12);
    puts("\n\n删除12后：");
    PrintBinHeap(H4);

    return 0;
}
on_the_roadd
关注
datastructure_斐波那契堆_二项堆_
10-02
2) 如果将二项堆的节点按照层序遍历的方式排列，那么它们会形成一个连续的非降序序列。二项堆的操作包括插入元素、删除元素（通常是最大或最小元素）、合并两个二项堆以及对元素进行修改。这些操作的时间复杂度在...
精选资源
山东大学数据结构与算法课程设计第2部分实验二项堆的实现和分析（含详细注释，可绘图）
最新发布
07-23
山东大学数据结构与算法课程设计第2部分实验二项堆的实现和分析（含详细注释，可绘图） （1）设计二项堆ADT，其上的基本操作包括：Make Heap (x), Find-Min, Union，Insert，Extract-Min，Decrease Key (x)，Delete...
二项堆（Binomial Heap）
02-18
二项堆（Binomial Heap）的c语言完全实现，包括添加，删除，和找到最小值，删除最小值
堆应用
bright_light_in_dark的博客
05-08 638
额，我又回来啦！！！
二叉堆（最小堆）+二项堆+斐波那契堆
05-19
二叉堆、二项堆和斐波那契堆是数据结构中的重要概念，它们都是堆数据结构的不同变体，主要用于高效地实现某些特定操作，如查找最大或最小元素、优先队列以及各种排序算法。在C++编程语言中，理解和实现这些堆结构...
二项堆算法实现.zip
04-02
完整的算法课设代码，用java写的，二项堆是二项树的集合，而二项树是基于递归定义的，即二项数Bk是一棵在Bk-1的基础上递归定义的有序树，它由两个Bk-1形成的，链接形成：一颗Bk-1树的根是另一棵Bk-1根的左儿子。...
算法导论之二项堆
医疗影像检索
08-01 3414
每件事物都有其应需而生的目的，既然存在了，一定有其出现的因和果。二项堆的存在，就是因为二叉堆在Union操作上性能不如意而被发明的。二项堆的Union操作只需O(lgn)时间就可以完成两个二项堆的合并（总共n个元素）。 二叉堆是完全二元树（二叉树）或者是近似完全二元树（二叉树）。二叉堆有两种：最大堆和最小堆。最大堆：父结点的键值总是大于或等于任何一个子节点的键值；最小堆：父结点的键值总是小于或等
3.2 二项堆
你的指尖有改变世界的力量
01-13 633
本文介绍二项堆的结构与实现原理
二项堆运用——hdu1512解题报告
fmt.Println(
11-09 2481
题目的大意是一堆数，选择其中的两个，如果他们是不同群体的话，就选出各自最大的一个，然后PK，减半，并合并在一起。 查找是否是两个不同的群体，首先应该想到的就是并查集。 接着就是思考是用什么数据结构，能够合并两个集合，在高级数据结构里面有二项堆和左偏树。 这里是用二项堆来写的，刚开始的时候一直没能把并查集和二项堆很好的运用在一起，看了一篇Pascal的代码，发现别人处理的很巧妙，就用每个二项堆
二项堆的概念与代码实现
ningtaohaha123的专栏
10-12 689
二项堆[编辑] 在计算机科学中，二项堆（binomial heap）是一种类似于二叉堆的堆结构。与二叉堆相比，其优势是可以快速合并两个堆，因此它属于可合并堆（mergeable heap）抽象数据类型的一种。 目录   [隐藏]  1 二项树2 二项堆3 二项堆的操作 3.1 合并3.2 插入3.3 查找最小关键字所在结点3.4 删除最
二项堆(Binominal Heap)
继科杂货店
01-04 995
可合并堆简介 The Intuition 类比 packet k阶二项树 对于上述 packet 要求 堆序二项树heap-ordered binominal tree 二项堆Binominal Heap 合并meldWith 添加新元素push 查找最小元素top 删除最小元素pop 完整序列操作演示 摊还分析 总结与展望 Acknowledgement 可合并堆简
堆之二项堆（Binominal Heap）
青少年趣味编程
02-18 272
二叉堆/二项堆/斐波那契堆 二叉堆/二项堆/斐波那契堆_m0_37683758的博客-优快云博客_二项堆 二项堆 二项堆_alike_meng的博客-优快云博客 堆之二项堆 堆之二项堆_跨世纪逃兵的专栏-优快云博客 可合并堆1：二项堆（Binominal Heap） 可合并堆1：二项堆（Binominal Heap）_robator的专栏-优快云博客_二项堆 合并 二项堆(Binominal Heap) 二项堆(Binominal Heap)_继科杂货店-优快云博
优先队列三大利器——二项堆、斐波那契堆、Pairing 堆
qiudesuo的专栏
11-03 1073
  优先队列三大利器——二项堆、斐波那契堆、Pairing 堆   本文内容框架： 写在前面的话 二项堆 二项堆的定义，操作，实现 斐波那契堆 斐波那契堆的定义，操作，实现 Pairing堆 Pairing 堆的定义，操作，实现 小结 写在前面的话 昨天发现，作者辛苦的劳动被一个无耻的人给窃取了——有一个人（csdn ID :qiaqia609）（...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值