二叉堆

二叉树

二叉树：是树的一种，主要的特点是二叉树的所有节点最多只有两个叶节点。除此之外没有别的要求
完全二叉树：就是在二叉树当中，除了最后一层之外，所有层的节点都有满的，且最后一层的节点也是从左到右的。优先填满左边的节点。
满二叉树：又是一种特殊的完全二叉树，满二叉树的最后一层也是满的。也就是说，除了最后一层的节点外所有的节点都有两个子节点，满二叉树的第i层节点数量为2^(i-1)。
二叉查找树(Binary Search Tree)，又称为有序二叉树，排序二叉树，满足以下性质：

1）没有键值相等的节点。

2）若左子树不为空，左子树上节点值均小于根节点的值。

3）若右子树不为空，右子树上节点值均大于根节点的值。
二叉查找树中对于目标节点的查找过程类似与有序数组的二分查找，并且查找次数不会超过树的深度。设节点数目为n，树的深度为h，假设树的每层都被塞满(第L层有2^L个节点，层数从1开始)，则根据等比数列公式可得h=log（n+1）。即最好的情况下，二叉查找树的查找效率为O(log n)。当二叉查找树退化为单链表时，比如，只有右子树的情况,如下图所示，此时查找效率为O(n)，如下图所示：

二叉堆

二叉堆是完全二元树或者是近似完全二元树，按照数据的排列方式可以分为两种：最大堆和最小堆。

下面是数组实现的最大堆和最小堆的示意图：

添加

假设在最大堆[90,80,70,60,40,30,20,10,50]种添加85，需要执行的步骤如下：

删除

假设从最大堆[90,85,70,60,80,30,20,10,50,40]中删除90，需要执行的步骤如下：

注意：从最大堆[90,85,70,60,80,30,20,10,50,40]中删除60，执行的步骤不能单纯的用它的字节点来替换；而必须考虑到"替换后的树仍然要是最大堆"！

源码实例（最大堆）

/*** 二叉堆(最大堆)**/
import java.util.ArrayList;
import java.util.List;
public class MaxHeap<T extends Comparable<T>> {private List<T> mHeap;    // 队列(实际上是动态数组ArrayList的实例)public MaxHeap() {this.mHeap = new ArrayList<T>();}/* * 最大堆的向下调整算法** 注：数组实现的堆中，第N个节点的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。** 参数说明：*     start -- 被下调节点的起始位置(一般为0，表示从第1个开始)*     end   -- 截至范围(一般为数组中最后一个元素的索引)*/protected void filterdown(int start, int end) {int c = start;          // 当前(current)节点的位置int l = 2*c + 1;     // 左(left)孩子的位置T tmp = mHeap.get(c);    // 当前(current)节点的大小while(l <= end) {int cmp = mHeap.get(l).compareTo(mHeap.get(l+1));// "l"是左孩子，"l+1"是右孩子if(l < end && cmp<0)l++;        // 左右两孩子中选择较大者，即mHeap[l+1]cmp = tmp.compareTo(mHeap.get(l));if(cmp >= 0)break;        //调整结束else {mHeap.set(c, mHeap.get(l));c = l;l = 2*l + 1;   }       }   mHeap.set(c, tmp);}/** 删除最大堆中的data** 返回值：*      0，成功*     -1，失败*/public int remove(T data) {// 如果"堆"已空，则返回-1if(mHeap.isEmpty() == true)return -1;// 获取data在数组中的索引int index = mHeap.indexOf(data);if (index==-1)return -1;int size = mHeap.size();mHeap.set(index, mHeap.get(size-1));// 用最后元素填补mHeap.remove(size - 1);                // 删除最后的元素if (mHeap.size() > 1)filterdown(index, mHeap.size()-1);    // 从index号位置开始自上向下调整为最小堆return 0;}/** 最大堆的向上调整算法(从start开始向上直到0，调整堆)** 注：数组实现的堆中，第N个节点的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。** 参数说明：*     start -- 被上调节点的起始位置(一般为数组中最后一个元素的索引)*/protected void filterup(int start) {int c = start;            // 当前节点(current)的位置int p = (c-1)/2;        // 父(parent)结点的位置 T tmp = mHeap.get(c);        // 当前节点(current)的大小while(c > 0) {int cmp = mHeap.get(p).compareTo(tmp);if(cmp >= 0)break;else {mHeap.set(c, mHeap.get(p));c = p;p = (p-1)/2;   }       }mHeap.set(c, tmp);}/* * 将data插入到二叉堆中*/public void insert(T data) {int size = mHeap.size();mHeap.add(data);    // 将"数组"插在表尾filterup(size);        // 向上调整堆}@Overridepublic String toString() {StringBuilder sb = new StringBuilder();for (int i=0; i<mHeap.size(); i++)sb.append(mHeap.get(i) +" ");return sb.toString();}public static void main(String[] args) {int i;int a[] = {10, 40, 30, 60, 90, 70, 20, 50, 80};MaxHeap<Integer> tree=new MaxHeap<Integer>();System.out.printf("== 依次添加: ");for(i=0; i<a.length; i++) {System.out.printf("%d ", a[i]);tree.insert(a[i]);}System.out.printf("\n== 最 大 堆: %s", tree);i=85;tree.insert(i);System.out.printf("\n== 添加元素: %d", i);System.out.printf("\n== 最 大 堆: %s", tree);i=90;tree.remove(i);System.out.printf("\n== 删除元素: %d", i);System.out.printf("\n== 最 大 堆: %s", tree);System.out.printf("\n");}
}

二项堆

二项堆是二项树的集合。在了解二项堆之前，先对二项树进行介绍。

二项树

二项树的定义

二项树是一种递归定义的有序树。它的递归定义如下：
(01) 二项树B0只有一个结点；
(02) 二项树Bk由两棵二项树B(k-1)组成的，其中一棵树是另一棵树根的最左孩子。

上图的B0、B1、B2、B3、B4都是二项树。对比前面提到的二项树的定义：B0只有一个节点，B1由两个B0所组成，B2由两个B1所组成，B3由两个B2所组成，B4由两个B3所组成；而且，当两颗相同的二项树组成另一棵树时，其中一棵树是另一棵树的最左孩子。

二项树的性质

二项树有以下性质：
[性质一] Bk共有2k个节点。
如上图所示，B0有20=1节点，B1有21=2个节点，B2有22=4个节点，...
[性质二] Bk的高度为k。
如上图所示，B0的高度为0，B1的高度为1，B2的高度为2，...
[性质三] Bk在深度i处恰好有C(k,i)个节点，其中i=0,1,2,...,k。
C(k,i)是高中数学中阶乘元素，例如，C(10,3)=(10*9*8) / (3*2*1)=240
B4中深度为0的节点C(4,0)=1
B4中深度为1的节点C(4,1)= 4 / 1 = 4
B4中深度为2的节点C(4,2)= (4*3) / (2*1) = 6
B4中深度为3的节点C(4,3)= (4*3*2) / (3*2*1) = 4
B4中深度为4的节点C(4,4)= (4*3*2*1) / (4*3*2*1) = 1
合计得到B4的节点分布是(1,4,6,4,1)。
[性质四] 根的度数为k，它大于任何其它节点的度数。
节点的度数是该结点拥有的子树的数目。

二项堆

二项堆是指满足以下性质的二项树的集合：
(01) 每棵二项树都满足最小堆性质。即，父节点的关键字 <= 它的孩子的关键字。
(02) 不能有两棵或以上的二项树具有相同的度数(包括度数为0)。换句话说，具有度数k的二项树有0个或1个。

上图就是一棵二项堆，它由二项树B0、B2和B3组成。对比二项堆的定义：(01)二项树B0、B2、B3都是最小堆；(02)二项堆不包含相同度数的二项树。

二项堆的第(01)个性质保证了二项堆的最小节点就是某个二项树的根节点，第(02)个性质则说明结点数为n的二项堆最多只有log{n} + 1棵二项树。实际上，将包含n个节点的二项堆，表示成若干个2的指数和(或者转换成二进制)，则每一个2个指数都对应一棵二项树。例如，13(二进制是1101)的2个指数和为13=23 + 22+ 20, 因此具有13个节点的二项堆由度数为3, 2, 0的三棵二项树组成。

基本定义

BinomialNode是二项堆的节点。它包括了关键字(key)，用于比较节点大小；度数(degree)，用来表示当前节点的度数；左孩子(child)、父节点(parent)以及兄弟节点(next)。
BinomialHeap是二项堆对应的类，它包括了二项堆的根节点mRoot以及二项堆的基本操作的定义。

public class BinomialHeap<T extends Comparable<T>> {private BinomialNode<T> mRoot;    // 根结点private class BinomialNode<T extends Comparable<T>> {T key;                // 关键字(键值)int degree;            // 度数BinomialNode<T> child;    // 左孩子BinomialNode<T> parent;    // 父节点BinomialNode<T> next;    // 兄弟节点public BinomialNode(T key) {this.key = key;this.degree = 0;this.child = null;this.parent = null;this.next = null;}public String toString() {return "key:"+key;}}...
}

内存图如下图所示：

合并操作

合并操作是二项堆的重点，它的添加操作也是基于合并操作来实现的。合并两个二项堆，需要的步骤概括起来如下：
(01) 将两个二项堆的根链表合并成一个链表。合并后的新链表按照"节点的度数"单调递增排列。
(02) 将新链表中"根节点度数相同的二项树"连接起来，直到所有根节点度数都不相同。

举例如下图所示：

第1步：将两个二项堆的根链表合并成一个链表
执行完第1步之后，得到的新链表中有许多度数相同的二项树。实际上，此时得到的是对应"Case 4"的情况，"树41"(根节点为41的二项树)和"树13"的度数相同，且"树41"的键值 > "树13"的键值。此时，将"树41"作为"树13"的左孩子。
第2步：合并"树41"和"树13"
执行完第2步之后，得到的是对应"Case 3"的情况，"树13"和"树28"的度数相同，且"树13"的键值 < "树28"的键值。此时，将"树28"作为"树13"的左孩子。
第3步：合并"树13"和"树28"
执行完第3步之后，得到的是对应"Case 2"的情况，"树13"、"树28"和"树7"这3棵树的度数都相同。此时，将x设为下一个节点。
第4步：将x和next_x往后移
执行完第4步之后，得到的是对应"Case 3"的情况，"树7"和"树11"的度数相同，且"树7"的键值 < "树11"的键值。此时，将"树11"作为"树7"的左孩子。
第5步：合并"树7"和"树11"
执行完第5步之后，得到的是对应"Case 4"的情况，"树7"和"树6"的度数相同，且"树7"的键值 > "树6"的键值。此时，将"树7"作为"树6"的左孩子。
第6步：合并"树7"和"树6"
此时，合并操作完成！

插入操作

插入操作可以看作是将"要插入的节点"和当前已有的堆进行合并。

删除操作

删除二项堆中的某个节点，需要的步骤概括起来如下：
(01) 将"该节点"交换到"它所在二项树"的根节点位置。方法是，从"该节点"不断向上(即向树根方向)"遍历，不断交换父节点和子节点的数据，直到被删除的键值到达树根位置。
(02) 将"该节点所在的二项树"从二项堆中移除；将该二项堆记为heap。
(03) 将"该节点所在的二项树"进行反转。反转的意思，就是将根的所有孩子独立出来，并将这些孩子整合成二项堆，将该二项堆记为child。
(04) 将child和heap进行合并操作。

举例如下图所示：

更新操作

更新二项堆中的某个节点，就是修改节点的值。

斐波那契堆

斐波那契堆(Fibonacci heap)是一种可合并堆，可用于实现合并优先队列。它比二项堆具有更好的平摊分析性能，它的合并操作的时间复杂度是O(1)。
与二项堆一样，它也是由一组堆最小有序树组成，并且是一种可合并堆。
与二项堆不同的是，斐波那契堆中的树不一定是二项树；而且二项堆中的树是有序排列的，但是斐波那契堆中的树都是有根而无序的。

基本定义

FibNode是斐波那契堆的节点类，它包含的信息较多。key是用于比较节点大小的，degree是记录节点的度，left和right分别是指向节点的左右兄弟，child是节点的第一个孩子，parent是节点的父节点，marked是记录该节点是否被删除第1个孩子(marked在删除节点时有用)。
FibHeap是斐波那契堆对应的类。min是保存当前堆的最小节点，keyNum用于记录堆中节点的总数，maxDegree用于记录堆中最大度，而cons在删除节点时来暂时保存堆数据的临时空间。

public class BinomialHeap<T extends Comparable<T>> {private BinomialNode<T> mRoot;    // 根结点private class BinomialNode<T extends Comparable<T>> {T key;                // 关键字(键值)int degree;            // 度数BinomialNode<T> child;    // 左孩子BinomialNode<T> parent;    // 父节点BinomialNode<T> next;    // 兄弟节点public BinomialNode(T key) {this.key = key;this.degree = 0;this.child = null;this.parent = null;this.next = null;}public String toString() {return "key:"+key;}}...
}

斐波那契堆是由一组最小堆组成，这些最小堆的根节点组成了双向链表(又叫"根链表")；斐波那契堆中的最小节点就是"根链表中的最小节点"！其内存图如下图所示：

插入操作

插入操作非常简单：插入一个节点到堆中，直接将该节点插入到"根链表的min节点"之前即可；若被插入节点比"min节点"小，则更新"min节点"为被插入节点。

斐波那契堆的根链表是"双向链表"，这里将min节点看作双向联表的表头。在插入节点时，每次都是"将节点插入到min节点之前(即插入到双链表末尾)"。此外，对于根链表中最小堆都只有一个节点的情况，插入操作就很演化成双向链表的插入操作。

合并操作

合并操作和插入操作的原理非常类似：将一个堆的根链表插入到另一个堆的根链表上即可。简单来说，就是将两个双链表拼接成一个双向链表。

获取最值操作

获取最小结点的操作是斐波那契堆中较复杂的操作。
(1）将要抽取最小结点的子树都直接串联在根表中；
(2）合并所有degree相等的树，直到没有相等的degree的树。

修改节点值操作

修改节点值包括减小节点值和增大节点值操作，以减小节点为例，减少斐波那契堆中的节点的键值，这个操作的难点是：如果减少节点后破坏了"最小堆"性质，如何去维护呢？下面对一般性情况进行分析。

(1) 首先，将"被减小节点"从"它所在的最小堆"剥离出来；然后将"该节点"关联到"根链表"中。倘若被减小的节点不是单独一个节点，而是包含子树的树根。则是将以"被减小节点"为根的子树从"最小堆"中剥离出来，然后将该树关联到根链表中。
(2) 接着，对"被减少节点"的原父节点进行"级联剪切"。所谓"级联剪切"，就是在被减小节点破坏了最小堆性质，并被切下来之后；再从"它的父节点"进行递归级联剪切操作。
而级联操作的具体动作则是：若父节点(被减小节点的父节点)的marked标记为false，则将其设为true，然后退出。
否则，将父节点从最小堆中切下来(方式和"切被减小节点的方式"一样)；然后递归对祖父节点进行"级联剪切"。
marked标记的作用就是用来标记"该节点的子节点是否有被删除过"，它的作用是来实现级联剪切。而级联剪切的真正目的是为了防止"最小堆"由二叉树演化成链表。
(3) 最后，别忘了对根链表的最小节点进行更新。