[硕.Love Python] BinomialHeap(B堆 & 二项堆)

class Node(object):
    def __init__(self, data):
        self.data = data
        self.child = None
        self.left = None
        self.right = None
        self.degree = 0

    def __str__(self):
        return str(self.data)

    __repr__ = __str__

class BinomialHeap(object):
    MAX_DEGREE = 20

    def __init__(self):
        self.root = None

    def combine(self, heap):
        self._dlistCombine(self.root, heap.root)

        if heap.root.data < self.root.data:
            self.root = heap.root

    def insert(self, data):
        node = Node(data)

        if self.root is None:
            self.root = node
            self._initSiblingList(node)
        else:
            self._addSibling(self.root, node)
            if data < self.root.data:
                self.root = node

    def pop(self):
        if self.root is None:
            raise ValueError(‘pop from empty heap.‘)

        res = self.root.data
        children = self.root.child
        siblings = self._dlistDelete(self.root)

        self.root = self._rebuild(children, siblings)

        return res

    def _rebuild(self, children, siblings):
        if children is None and siblings is None:
            return None

        treeArr = [None] * BinomialHeap.MAX_DEGREE
        self._combineTrees(treeArr, children)
        self._combineTrees(treeArr, siblings)

        head = None
        treeIterator = iter(treeArr)

        for node in treeIterator:
            if node:
                break

        root = head = prev = node
        for node in treeIterator:
            if node:
                prev.right = node
                node.left = prev
                prev = node
                if node.data < root.data:
                    root = node

        head.left = prev
        prev.right = head

        return root

    def _combineTrees(self, treeArr, head):
        if head is None:
            return 
        
        node = head
        while True:
            tmp = node
            node = node.right

            for i in xrange(tmp.degree, len(treeArr)):
                if treeArr[i] is None:
                    break
                tmp = self._joinTree(tmp, treeArr[i])
                treeArr[i] = None
            else:
                raise Exception(‘max degree‘)
            treeArr[i] = tmp
            if node is head:
                break

    def _joinTree(self, tree1, tree2):
        if tree2.data < tree1.data:
            tree1, tree2 = tree2, tree1

        self._addChild(tree1, tree2)
        return tree1

    def _dlistInit(self, head):
        head.left = head.right = head

    def _dlistCombine(self, head1, head2):
        r1 = head1.right
        l2 = head2.left

        head1.right = head2
        head2.left = head1
        r1.left = l2
        l2.right = r1

    def _dlistInsert(self, head, node):
        node.left = head
        node.right = head.right 

        node.right.left = node
        head.right = node

    def _dlistDelete(self, node):
        if node.left is node:
            newHead = None
        else:
            node.left.right = node.right
            node.right.left = node.left
            newHead = node.right

        return newHead

    _initSiblingList = _dlistInit
    _addSibling = _dlistInsert

    def _addChild(self, parent, child):
        if parent.child is None:
            parent.child = child
            self._initSiblingList(child)
        else:
            self._addSibling(parent.child, child)
        parent.degree += 1

if __name__ == ‘__main__‘:
    from random import sample

    data = range(1, 100000)
    data1 = sample(data, 1000)
    data2 = sample(data, 20000)

    heap1 = BinomialHeap()
    map(heap1.insert, data1)

    for _ in xrange(100):
        print heap1.pop(),
    print

    heap2 = BinomialHeap()
    map(heap2.insert, data2)

    heap1.combine(heap2)
    print ‘-‘ * 80
    for _ in xrange(200):
        print heap1.pop(),

刘硕老师Python精品课程:

《Python高级编程技巧实战》:

http://coding.imooc.com/class/62.html

 

《Python算法实战视频课程》:

http://study.163.com/course/courseMain.htm?courseId=1003617013

 

《Python科学计算—NumPy实战课程》:

http://edu.51cto.com/course/course_id-5046.html

 

熊猫TV直播间:

http://www.panda.tv/671023

[硕.Love Python] BinomialHeap(B堆 & 二项堆)

时间: 2024-12-17 05:26:05

[硕.Love Python] BinomialHeap(B堆 & 二项堆)的相关文章

二项堆

在计算机科学中,二项堆(Binomial Heap)是一种堆结构.与二叉堆(Binary Heap)相比,其优势是可以快速合并两个堆,因此它属于可合并堆(Mergeable Heap)数据结构的一种. 可合并堆通常支持下面几种操作: Make-Heap():创建并返回一个不包含任何元素的新堆. Insert(H, x):将节点 x 插入到堆 H 中. Minimum(H):返回堆 H 中的最小关键字. Extract-Min(H):将堆 H 中包含最小关键字的节点删除. Union(H1, H2

二项堆(一)之 图文解析 和 C语言的实现

概要 本章介绍二项堆,它和之前所讲的堆(二叉堆.左倾堆.斜堆)一样,也是用于实现优先队列的.和以往一样,本文会先对二项堆的理论知识进行简单介绍,然后给出C语言的实现.后续再分别给出C++和Java版本的实现:实现的语言虽不同,但是原理一样,选择其中之一进行了解即可.若文章有错误或不足的地方,请不吝指出! 目录1. 二项树的介绍2. 二项堆的介绍3. 二项堆的基本操作4. 二项堆的C实现(完整源码)5. 二项堆的C测试程序 转载请注明出处:http://www.cnblogs.com/skywan

算法导论 二项堆

可以合并的堆 二项堆 先看看堆得操作运行时间的对比 对于使用这种数据结构有个概念 二项堆在union操作合并上有优势 二项堆由二项树组成 我们先看看二项树的定义 因为性质3中的系数就是二项式分布的系数,所以二项树名由此得来 B0 有2º = 1个节点 B? 有2¹=2个节点 且根节点比子节点小 B? 有2²=4个节点 且根节点比子节点小 B? 有2³=8个节点 且根节点比子节点小 二项堆则按照以下规则有二项树组成 由图 因为二项堆都是最小堆有序的,最小节点必定在跟节点中,寻找最小关键字就比较简单

深度解析(十三)二项堆

二项堆(一)之 图文解析 和 C语言的实现 概要 本章介绍二项堆,它和之前所讲的堆(二叉堆.左倾堆.斜堆)一样,也是用于实现优先队列的.和以往一样,本文会先对二项堆的理论知识进行简单介绍,然后给出C语言的实现.后续再分别给出C++和Java版本的实现:实现的语言虽不同,但是原理一样,选择其中之一进行了解即可.若文章有错误或不足的地方,请不吝指出! 目录1. 二项树的介绍2. 二项堆的介绍3. 二项堆的基本操作4. 二项堆的C实现(完整源码)5. 二项堆的C测试程序 转载请注明出处:http://

12、【堆】二项堆

一.二项树的介绍 二项树的定义 二项堆是二项树的集合.在了解二项堆之前,先对二项树进行介绍. 二项树是一种递归定义的有序树.它的递归定义如下: (1) 二项树B0只有一个结点: (2) 二项树Bk由两棵二项树B(k-1)组成的,其中一棵树是另一棵树根的最左孩子. 如下图所示: 上图的B0.B1.B2.B3.B4都是二项树.对比前面提到的二项树的定义:B0只有一个节点,B1由两个B0所组成,B2由两个B1所组成,B3由两个B2所组成,B4由两个B3所组成:而且,当两颗相同的二项树组成另一棵树时,其

数据结构——二项堆

二项树的介绍 二项树的定义 二项堆是二项树的集合.在了解二项堆之前,先对二项树进行介绍. 二项树是一种递归定义的有序树.它的递归定义如下:(01) 二项树B0只有一个结点:(02) 二项树Bk由两棵二项树B(k-1)组成的,其中一棵树是另一棵树根的最左孩子.如下图所示: 上图的B0.B1.B2.B3.B4都是二项树.对比前面提到的二项树的定义:B0只有一个节点,B1由两个B0所组成,B2由两个B1所组成,B3由两个B2所组成,B4由两个B3所组成:而且,当两颗相同的二项树组成另一棵树时,其中一棵

笔试算法题(46):简介 - 二叉堆 &amp; 二项树 &amp; 二项堆 &amp; 斐波那契堆

二叉堆(Binary Heap) 二叉堆是完全二叉树(或者近似完全二叉树):其满足堆的特性:父节点的值>=(<=)任何一个子节点的键值,并且每个左子树或者右子树都是一 个二叉堆(最小堆或者最大堆):一般使用数组构建二叉堆,对于array[i]而言,其左子节点为array[2*i],其右子节点为 array[2*i+1]:二叉堆支持插入,删除,查找最大(最小)键值的操作,但是合并二叉堆的复杂度较高,时间复杂度为O(N):但是二项堆或者斐波 那契堆则仅需要O(logN): 二项树(Binomial

优先队列(堆)&#183;二项队列

目录 一. 定义 二. 结构 三. 操作 3.1. 合并 3.1. 删除最小值(deleteMin) 四. 二项队列的实现 代码地址 一. 定义 ? 我们知道,左式堆每次操作的时间界是\(O(logN)\).二项队列支持合并.插入.删除最小值,每次插入的平均时间为常数时间,而最坏时间是\(O(logN)\). ? 二项队列: 不是一棵堆序的树,而是堆序的树的集合,成为森林. 森林的每棵树都是二项树(binomial tree). 每个高度上至多存在一棵二项树. 二. 结构 ? 结构图解: ? 高

《数据结构与算法分析:C语言描述》复习——第五章“堆”——二叉堆

2014.06.15 22:14 简介: 堆是一种非常实用的数据结构,其中以二叉堆最为常用.二叉堆可以看作一棵完全二叉树,每个节点的键值都大于(小于)其子节点,但左右孩子之间不需要有序.我们关心的通常只有堆顶的元素,而整个堆则被封装起来,保存在一个数组中. 图示: 下图是一个最大堆: 实现: 优先队列是STL中最常用的工具之一,许多算法的优化都要利用堆,使用的工具就是优先队列.STL中的优先队列通过仿函数来定义比较算法,此处我偷懒用了“<”运算符.关于使用仿函数的好处,我之后如果有时间深入学习S