二项堆、二项树—优先队列（Java实现）

最新推荐文章于 2019-05-16 16:53:37 发布
最新推荐文章于 2019-05-16 16:53:37 发布
阅读量450 收藏 2
点赞数
分类专栏： 数据结构

二项堆

（binomial heap）是一种类似于二叉堆的堆结构。二项堆是指满足以下性质的二项树的集合，每一棵堆序树都是由约束的形式，叫做二项树。与二叉堆相比，其优势是可以快速合并两个堆，因此它属于可合并堆（mergeable heap）抽象数据类型的一种。

 

二项堆属性：

在一个高度为K的二项树中：

1. 根节点有K个儿子

2.树有2^{k}个节点

3. 树的高度为K

4. 二项树B_{k}子树由一个带有儿子B_{0}、B_{1}、、、B_{k-1} 的根组成。

5 .每棵二项树都满足最小堆性质，即结点关键字大于等于其父结点的值

6 .不能有两棵或以上的二项树有相同度数（包括度数为0）。换句话说，具有度数k的二项树有0个或1个。

 

二项树

度数为0的二项树只包含一个结点。

度数为k的二项树有一个根结点，根结点下有k个子女，每个子女分别是度数分别为{\displaystyle k-1,k-2,...,2,1,0}的二项树的根。

  度为0的二项树

  度为1的二项树

   度为2的二项树

 度为3的二项树

代码：

二项堆节点

class BinomialHeapNode
{
    int key, degree;
    BinomialHeapNode parent;
    BinomialHeapNode sibling;
    BinomialHeapNode child;
 
    /* Constructor */
    public BinomialHeapNode(int k) 
    {
        key = k;
        degree = 0;
        parent = null;
        sibling = null;
        child = null;        
    }
    /* Function reverse */
    public BinomialHeapNode reverse(BinomialHeapNode sibl) 
    {
            BinomialHeapNode ret;
            if (sibling != null)
                ret = sibling.reverse(this);
            else
                ret = this;
            sibling = sibl;
            return ret;
    }
    /* Function to find min node */
    public BinomialHeapNode findMinNode() 
    {
            BinomialHeapNode x = this, y = this;
            int min = x.key;
 
            while (x != null) {
                if (x.key < min) {
                    y = x;
                    min = x.key;
                }
                x = x.sibling;
            }
 
            return y;
    }
    /* Function to find node with key value */
    public BinomialHeapNode findANodeWithKey(int value) 
    {
            BinomialHeapNode temp = this, node = null;
 
            while (temp != null) 
            {
                if (temp.key == value) 
                {
                    node = temp;
                    break;
                }
                if (temp.child == null)
                    temp = temp.sibling;
                else 
                {
                    node = temp.child.findANodeWithKey(value);
                    if (node == null)
                        temp = temp.sibling;
                    else
                        break;
                }
            }
 
            return node;
    }
    /* Function to get size */
    public int getSize() 
    {
        return (1 + ((child == null) ? 0 : child.getSize()) + ((sibling == null) ? 0 : sibling.getSize()));
    }
}

二项堆：

class BinomialHeap
{
    private BinomialHeapNode Nodes;
    private int size;
 
    /* Constructor */
    public BinomialHeap()
    {
        Nodes = null;
        size = 0;
    }
    /* Check if heap is empty */
    public boolean isEmpty()
    {
        return Nodes == null;
    }
    /* Function to get size */
    public int getSize()
    {
        return size;
    }
    /* clear heap */
    public void makeEmpty()
    {
        Nodes = null;
        size = 0;
    }
    /* Function to insert */        
    public void insert(int value) 
    {
        if (value > 0)
        {
            BinomialHeapNode temp = new BinomialHeapNode(value);
            if (Nodes == null) 
            {
                Nodes = temp;
                size = 1;
            } 
            else 
            {
                unionNodes(temp);
                size++;
            }
        }
    }
    /* Function to unite two binomial heaps */
    private void merge(BinomialHeapNode binHeap) 
    {
        BinomialHeapNode temp1 = Nodes, temp2 = binHeap;
 
        while ((temp1 != null) && (temp2 != null)) 
        {
            if (temp1.degree == temp2.degree) 
            {
                BinomialHeapNode tmp = temp2;
                temp2 = temp2.sibling;
                tmp.sibling = temp1.sibling;
                temp1.sibling = tmp;
                temp1 = tmp.sibling;
            } 
            else 
            {
                if (temp1.degree < temp2.degree) 
                {
                    if ((temp1.sibling == null) || (temp1.sibling.degree > temp2.degree)) 
                    {
                        BinomialHeapNode tmp = temp2;
                        temp2 = temp2.sibling;
                        tmp.sibling = temp1.sibling;
                        temp1.sibling = tmp;
                        temp1 = tmp.sibling;
                    }
                    else 
                    {
                        temp1 = temp1.sibling;
                    }
                }
                else 
                {
                    BinomialHeapNode tmp = temp1;
                    temp1 = temp2;
                    temp2 = temp2.sibling;
                    temp1.sibling = tmp;
                    if (tmp == Nodes) 
                    {
                        Nodes = temp1;
                    }
                    else 
                    {
 
                    }
                }
            }
        }
        if (temp1 == null) 
        {
            temp1 = Nodes;
            while (temp1.sibling != null) 
            {
                temp1 = temp1.sibling;
            }
            temp1.sibling = temp2;
        } 
        else
        {
 
        }
    }
    /* Function for union of nodes */
    private void unionNodes(BinomialHeapNode binHeap) 
    {
        merge(binHeap);
 
        BinomialHeapNode prevTemp = null, temp = Nodes, nextTemp = Nodes.sibling;
 
        while (nextTemp != null) 
        {
            if ((temp.degree != nextTemp.degree) || ((nextTemp.sibling != null) && (nextTemp.sibling.degree == temp.degree))) 
            {                
                prevTemp = temp;
                temp = nextTemp;
            } 
            else
            {
                if (temp.key <= nextTemp.key) 
                {
                    temp.sibling = nextTemp.sibling;
                    nextTemp.parent = temp;
                    nextTemp.sibling = temp.child;
                    temp.child = nextTemp;
                    temp.degree++;
                } 
                else 
                {
                    if (prevTemp == null) 
                    {
                        Nodes = nextTemp;
                    }
                    else 
                    {
                        prevTemp.sibling = nextTemp;
                    }
                    temp.parent = nextTemp;
                    temp.sibling = nextTemp.child;
                    nextTemp.child = temp;
                    nextTemp.degree++;
                    temp = nextTemp;
                }
            }
            nextTemp = temp.sibling;
        }
    }
    /* Function to return minimum key */
    public int findMinimum() 
    {
        return Nodes.findMinNode().key;
    }
    /* Function to delete a particular element */
    public void delete(int value) 
    {
        if ((Nodes != null) && (Nodes.findANodeWithKey(value) != null)) 
        {
            decreaseKeyValue(value, findMinimum() - 1);
            extractMin();
        }
    }
    /* Function to decrease key with a given value */
    public void decreaseKeyValue(int old_value, int new_value) 
    {
        BinomialHeapNode temp = Nodes.findANodeWithKey(old_value);
        if (temp == null)
            return;
        temp.key = new_value;
        BinomialHeapNode tempParent = temp.parent;
 
        while ((tempParent != null) && (temp.key < tempParent.key)) 
        {
            int z = temp.key;
            temp.key = tempParent.key;
            tempParent.key = z;
 
            temp = tempParent;
            tempParent = tempParent.parent;
        }
    }
    /* Function to extract the node with the minimum key */
    public int extractMin() 
    {
        if (Nodes == null)
            return -1;
 
        BinomialHeapNode temp = Nodes, prevTemp = null;
        BinomialHeapNode minNode = Nodes.findMinNode();
 
        while (temp.key != minNode.key) 
        {
            prevTemp = temp;
            temp = temp.sibling;
        }
 
        if (prevTemp == null) 
        {
            Nodes = temp.sibling;
        }
        else
        {
            prevTemp.sibling = temp.sibling;
        }
 
        temp = temp.child;
        BinomialHeapNode fakeNode = temp;
 
        while (temp != null) 
        {
            temp.parent = null;
            temp = temp.sibling;
        }
 
        if ((Nodes == null) && (fakeNode == null))
        {
            size = 0;
        } 
        else
        {
            if ((Nodes == null) && (fakeNode != null)) 
            {
                Nodes = fakeNode.reverse(null);
                size = Nodes.getSize();
            }
            else
            {
                if ((Nodes != null) && (fakeNode == null))
                {
                    size = Nodes.getSize();
                }
                else
                {
                    unionNodes(fakeNode.reverse(null));
                    size = Nodes.getSize();
                }
            }
        }
 
        return minNode.key;
    }
 
    /* Function to display heap */
    public void displayHeap()
    {
        System.out.print("\nHeap : ");
        displayHeap(Nodes);
        System.out.println("\n");
    }
    private void displayHeap(BinomialHeapNode r)
    {
        if (r != null)
        {
            displayHeap(r.child);
            System.out.print(r.key +" ");
            displayHeap(r.sibling);
        }
    }    
}

参考：

https://zh.wikipedia.org/wiki/%E4%BA%8C%E9%A1%B9%E5%A0%86

https://www.sanfoundry.com/java-program-implement-binomial-heap/

https://www.youtube.com/watch?v=7UQd9SYUoNk

 

 

 

吴晶鑫
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
优先队列(堆)·二项队列
weixin_30363981的博客
04-01 79
目录 一、 定义 二、 结构 三、 操作 3.1、 合并 3.1、 删除最小值（deleteMin） 四、 二项队列的实现 代码地址 一、 定义 ​ 我们知道，左式堆每次操作的时间界是\(O(logN)...
java中3 2=2_二项堆(三)之 Java的实现
weixin_36170641的博客
02-25 249
概要前面分别通过C和C++实现了二项堆，本章给出二项堆的Java版本。还是那句老话，三种实现的原理一样，择其一了解即可。二项树的介绍二项树的定义二项堆是二项树的集合。在了解二项堆之前，先对二项树进行介绍。二项树是一种递归定义的有序树。它的递归定义如下：(01) 二项树B0只有一个结点；(02) 二项树Bk由两棵二项树B(k-1)组成的，其中一棵树是另一棵树根的最左孩子。如下图所示：上图的B0、B1...
二项式堆（Binomial Heap）
weixin_30399797的博客
02-18 340
在计算机科学中，Binomial Heap类似于二叉堆但是支持两个堆的快速合并。这是通过一个特殊的树结构完成的。 binomial tree定义 0阶的 binomial tree是一个结点。 k阶的 binomial tree有如下特点：k阶的Binomial Heap的根节点依次是k-1,k-2,...,0(以此顺序)阶 binomial tree的根节点的父结点。 k阶 ...
二项堆 之 Java的实现
Code-lover's Learning Notes
08-15 1145
二项树的介绍二项树的定义二项堆是二项树的集合。在了解二项堆之前，先对二项树进行介绍。二项树是一种递归定义的有序树。它的递归定义如下： (01) 二项树B0只有一个结点； (02) 二项树Bk由两棵二项树B(k-1)组成的，其中一棵树是另一棵树根的最左孩子。 如下图所示：上图的B0、B1、B2、B3、B4都是二项树。对比前面提到的二项树的定义：B0只有一个节点，B1由两个B0所组成，B2由两个B
二项堆(三)之 Java的实现
kk的博客
04-16 99
概要 前面分别通过C和C++实现了二项堆，本章给出二项堆的Java版本。还是那句老话，三种实现的原理一样，择其一了解即可。 目录1.二项树的介绍2.二项堆的介绍3.二项堆的基本操作4.二项堆的Java实现(完整源码)5.二项堆的Java测试程序 转载请注明出处：http://www.cnblogs.com/skywang12345/p/3656098.html ...
用java实现二叉查找树、堆和优先队列
01-20
二叉查找树是以一种特殊的二叉树... 　遍历元素：遍历主要有中序、前序、后序、深度优先、广度优先等。 　下面这个类包括了结点的定义还有二叉树的定义。 package binaryTree; public class BinaryTree {  //
Java基于堆结构实现优先队列功能示例
08-28
Java基于堆结构实现优先队列功能示例 Java基于堆结构实现优先队列功能示例是介绍Java语言中基于堆结构实现优先队列功能的示例程序。该示例程序主要介绍了Java基于堆结构实现优先队列功能的简单定义与使用方法，并...
优先队列-java可以选择属性和升序降序
06-14
Java中的`java.util.PriorityQueue`类为我们提供了实现优先队列的功能。 首先，让我们深入理解`PriorityQueue`的基本概念。`PriorityQueue`是基于二叉堆（一种自平衡的树形数据结构）实现的，它不保证队列的顺序，...
Binomial-Heap:一个java二项堆实现
06-26
在Java编程中，实现二项堆可以帮助我们优化某些算法，特别是涉及频繁插入和合并操作的情况。下面将详细介绍二项堆的原理、特点以及如何用Java进行实现。 **二项堆的基本概念** 二项堆是由多个二项树（每个二项树的...
用堆实现简单的优先队列（JAVA）
04-13
在Java中，我们可以利用堆（Heap）来实现一个简单的优先队列。堆是一种二叉树形数据结构，其每个父节点的值都大于或等于其子节点的值，这样的结构被称为最大堆。 在给定的文件中，我们有两个文件：PriorityQueue....
二项堆算法实现.zip
04-02
完整的算法课设代码，用java写的，二项堆是二项树的集合，而二项树是基于递归定义的，即二项数Bk是一棵在Bk-1的基础上递归定义的有序树，它由两个Bk-1形成的，链接形成：一颗Bk-1树的根是另一棵Bk-1根的左儿子。而且组成二项堆的所有二项树的根结点的度数从左向右逐渐增加。
lazy_binomial_heap的python实现——lazy 二项堆——优先队列。
06-22
lazy binomial heaps的oython实现，优先队列。采用双向循环链表实现，api：merge,insert,find_min,extractMin,coalesce_step,updateMin。
Binomial heaps 的实现和分析
07-03
1、抽象数据类型定义如下： 本程序主要定义了两个类，一个用于创建节点，另一个用于创建二项堆。 class BinomialHeapNode { public: int key; //节点的关键字的值 int degree; //节点的度 BinomialHeapNode* sibling; //节点的右兄弟节点 BinomialHeapNode* child; //节点的最最孩子节点 BinomialHeapNode* father; //节点的双亲节点 BinomialHeapNode(int newkey) ; //构造函数，以关键字创建节点 BinomialHeapNode(); //重载构造函数，默认关键字为0 }; class BinomialHeap { public: typedef BinomialHeapNode node_t; private: static BinomialHeap heapMerge(BinomialHeap& heapA, BinomialHeap& heapB) ; //将两个二项堆按照根的度的递增顺序构成一个新的二项堆 static void nodeLink(node_t* child, node_t* father) ; //将两个节点连接成二项树 public: node_t* head; //二项堆的头节点 BinomialHeap(); //构造函数，头结点为0 { head = 0 } BinomialHeap(node_t& node) //构造函数，以一个节点进行构造 { head = &node; } BinomialHeap(node_t* node) //构造函数，以一个节点进行构造 { head = node; } BinomialHeap(const BinomialHeap& src) //构造函数，以一个二项堆进行构造 { head = src.head; } inline void insertNode(node_t& node) ; //在堆中插入一个节点 void insertNode(node_t* node) ; //在堆中插入一个节点 node_t* Find_Min(); //查找关键字值最小的节点 node_t* Extract_Min(); //查找并删除关键字值最小的节点 static BinomialHeap heapUnion(BinomialHeap& heapA, BinomialHeap& heapB) ; //合并两个二项堆 node_t*Findnode(int key) ; //查找关键字为key的节点 inline void swapkey(node_t* source,node_t*target ) ; //交换两个节点的关键字的值 void decreaseKey(int key,int newkey) ; //减小关键字为key的节点的值为newkey void traverse(); //遍历二项堆 void DeleteNode(int key) ; //删除关键字为key的节点 };
分别对无序数组和有序数组建立二叉树，实现遍历和查找
01-22
关于二叉树的程序，分别对无序数组和有序数组建立二叉树，实现遍历和查找。
结构之美——优先队列三大结构（一）——二项堆
小熊不去实验室
11-02 8451
这三篇文章主要讲解二项堆、斐波那契堆、Pairing 堆，这三种结构主要用于优先队列的实现。资料主要参考《算法导论》和或互联网。   《算法导论》第19章讲到了二项堆   1.二项堆简介                                                                                   二项堆是二项堆是由一组二项树组成
优先队列之二项队列(JAVA实现)
MC的博客
06-18 1109
优先队列至二项队列的理解以及JAVA实现
基于堆实现的优先级队列
practice
05-16 398
/** * @author qcg * @version 2019/5/16. * @description 优先队列，二叉堆是实现优先队列的基础。该例中二叉堆属于大堆 * 应用场景： * 1.topK问题 * 2.不需要FIFO按照权重操作出队的情况 * 3.RabbitMQ中，当消费者不足，不能及时进行消费的情况下，优先级队列会生效 * 4.hadoop中Map结束之后会将IF...
基于堆的优先级队列
NETWILLIAM的专栏
10-27 618
在一个包含n个元素的堆中,所有优先级队列的操作都可以在O(lgn)时间内完成. 这些操作包括: INSERT(S, x): 把元素x插入队列S中.这一操作等价于S=S并{x} MAXIMUM(S): 返回S中具有最大关键值的元素 EXTRACT-MAX(S): 去掉并返回S中具有最大关键值的元素 INCREASE-KEY(S, x, k): 将元素x的关键值增加到k,这里假设k的值不小于
半路算法之二项树与二项堆
ds1231h的博客
04-15 923
秉承前文。前面提到过针对稀疏图时，以二项堆来作为最小优先队列是更为适宜的。这里记录一下学习二项堆的过程。二项堆的名字来源于二项树。二项堆是多个二项树连在了一起。 二项树的名字来源于其//(B_n//)棵树的元素个数为2^n，且其深度n处恰有\(2^k\)个节点，其性质与二项式非常吻合。此外，它还是一种递归定义的有序树。
在Java中，优先队列的使用
最新发布
04-06
4. 堆排序：堆排序是一种基于优先队列的排序算法，利用优先队列的性质来实现排序。 5. 模拟系统：优先队列可以用于模拟系统中的事件顺序，按照优先级处理事件。 在Java中，优先队列的实现可以使用Java集合框架中的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值