6、二项队列及其分析
作为摊还分析的另一个例子(实际上比斜堆更经典),这一篇我们来介绍二项队列。
一、二项树
二项队列是一列二项树组成的,先来介绍二项树:
定义:二项树是这样定义的:
1、一个单结点可以作为二项树$B_0$,其秩为$0$;
2、二项树$B_k$的秩是$k$,且是由两棵$B_{k-1}$合并而成的,其中一棵作为子树连接在另一棵的根上。
这样解释不太清楚,我们画出图来:
比较一目了然。
二项树作为一种树,它的限制比较强,因此也有非常多十分好的性质。对于我们建构二项队列来说主要有以下几点:
1、二项树$B_k$由两棵$B_{k-1}$合并即可得来;
2、二项树$B_k$总共拥有$2^k$个结点;
3、二项树$B_k$的树根总共拥有$k$个子树,并且它们分别是二项树$B_0, B_1, ... ,B_{k-1}$;
4、二项树$B_k$树根的高度是$k$。
这4条性质的证明就不赘述了,从图上可以轻易看出。另外二项树还有一个更有意思的性质:二项树$B_k$中,高度为$h$的结点共有$C_{k}^{h}$个。这个性质对二项队列的帮助有限,因此也不证明了。
有了二项树的定义,我们就可以介绍二项队列了。
二、二项队列
二项队列是一种优先队列的实现方式。二叉堆作为基本的堆已经足够好,只是合并操作的复杂度不太能接受(单次$O(N)$)。为了支持高效的合并操作,左偏树和斜堆出现。但左偏树和斜堆由于不再是完全二叉树,因此实现时必须用到指针式结构,从而它们的建堆反而不能像二叉堆一样以$O(N)$完成。二项队列则可以兼顾,既以$O(N)$完成建堆,又以$O(log N)$完成合并,同时其它操作的复杂度不降低。因此,二项队列是十分重要的。
一个二项队列由一列满足堆序的二项树组成。所谓满足堆序,复习二叉堆时已经提到,就是每个结点与它的每个儿子都保持同一种序关系,从而二项队列是一些堆序树的森林。
除此之外,二项队列还要求:对任意正整数$k$,一个二项队列里至多有一棵二项树$B_k$。这样,相当于二项树们以二进制的形式来表示原本用一棵树来表示的结构。譬如二项队列$Q$拥有$19$个结点,由于$19 = (10011)_2$,从而$Q$就拥有(而且必然是)$B_0$、$B_1$和$B_4$三棵二项树。如果不考虑树的顺序,那么只要结点数给定,二项队列的结构就已经被决定了。进而,一个有$N$个结点的二项队列,它的二项树的棵数就是$O(log N)$的。
由于这种性质,我们可以用一个数组来存储二项队列的诸多二项树。由于这个数据结构不能太庞大,从而数组的大小也很小。用数组来存比链表要优越得多,因为数组可以明确地保存某棵二项树的秩,并且可以让我们立刻找到二项队列里的秩为$r$的二项树。用链表的唯一好处就是省略了之间不存在二项树的位置,但是对数组来讲,这只是一个$O(1)$的损耗。
刚刚已经提到,一棵二项树$B_k$树根的子树分别是二项树$B_0$到$B_{k-1}$,这也明确地告诉我们,它的诸子树也算一个二项队列。不过,这个二项队列我们不需要快速找到每棵子树,而只需要在树根被删除时提取出来(下面会介绍到),同时它的每个位置又都有二项树,从而用一个链表是更合适的选择。
从而,二项队列里的一棵二项树的子树的存储方式就应该是一个链表(也就是表头),另外每个二项树结点自己也有可能是链表上的结点,从而也要存储链表的后继结点,这样,一个二项树结点的内容就决定了,也就是所谓的“左儿子右兄弟”的原则。二项树和二项队列的声明如下:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 struct BinTree { 2 int val; //键值 3 int rank; //秩 4 int size; //树的大小 5 BinTree* leftSon; //最左侧的儿子 6 BinTree* rightBro; 7 //右兄弟,链表存储二项树的儿子们 8 }; 9 10 struct BinQueue { 11 int size; //队列的大小 12 BinTree* tree[21]; //二项队列的各项 13 };
现在,我们来介绍二项队列作为优先队列的一些操作以及实现。以维持小根为例。
1、合并二项队列(Merge):二项队列的核心算法。合并两个二项队列类似于二进制加法,甚至有进位这种情况。新的二项队列必须满足条件,每种二项树都至多只有一棵,所以合并的时候是如此操作的:
将$Q_1$和$Q_2$合并成新队列。从新队列的第$0$棵二项树开始逐位考虑。对于第$i$棵二项树的临时数量来分类讨论,可能是两个队列都没有,而且也没有进位,这样新队列也没有这种二项树;也有可能是只有$Q_1$拥有这种二项树,或者是只有$Q_2$有,或者只是进位,总之只有一棵,则新队列只要继承这棵二项树即可;可能是有两棵,这样新队列没有这种二项树,而向下一位进位一棵合并后的二项树;可能是有三棵,这样任选其中一棵放在新队列里即可,剩余的两棵合并后进位。
可以看出,一次合并操作的时间复杂度是$O(log N_1 + log N_2) = O(log N)$的。
为了保证这一点,两棵二项树的合并必须是$O(1)$的。由于刚刚提到,二项树是用链表存储的。一棵二项树只能并到另一棵同秩的二项树上,而且合并后,它必然是新树根的最大的子树(因为树根原本的子树都是更小的)。从而告诉我们,二项树的“左儿子右兄弟”中,最左侧的表头是最大的树。这样,合并时只要把作为子树的树放在表头即可,自然是$O(1)$的。二项树的合并、二项队列的合并的一种实现如下:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 BinTree* MergeBinTree(BinTree* T1, BinTree* T2) { 2 //合并二项树 3 if (T1->rank != T2->rank) { 4 printf("TreeMerging error: non same rank "); 5 return NULL; 6 } //只有同秩的才允许合并 7 8 if (T1->val > T2->val) //维持堆序 9 return MergeBinTree(T2, T1); 10 11 (T1->rank)++; //秩增1 12 (T1->size) <<= 1; //大小翻倍 13 T2->rightBro = T1->leftSon; 14 T1->leftSon = T2; 15 //把新儿子(必然是最大的放在最左侧),并维持链表 16 return T1; 17 } 18 19 BinQueue* MergeBinQueue(BinQueue* Q1, BinQueue* Q2) { 20 //合并两个二项队列 21 if (Q1->size + Q2->size >= 1024 * 1024) { //超限 22 printf("QueueMerging error: exceeded "); 23 return NULL; 24 } 25 26 BinTree *temp1 = NULL, *temp2 = NULL, *pushin = NULL; 27 28 (Q1->size) += (Q2->size); 29 int S = Q1->size; 30 int cas; 31 for (int i = 0, j = 1; j <= S; i++, j <<= 1) { 32 temp1 = Q1->tree[i]; 33 temp2 = Q2->tree[i]; 34 cas = (!!temp1) + 2 * (!!temp2) + 4 * (!!pushin); 35 switch (cas) { //二进制加法,在某一位上有8种情况 36 case 0: //无秩i树 37 case 1: //只有Q1有秩i树 38 break; 39 case 2: //只有Q2有秩i树,转移到Q1上 40 Q1->tree[i] = temp2; 41 Q2->tree[i] = NULL; 42 break; 43 case 3: // Q1、Q2都有但没有进位,则进位并清空Q1、Q2 44 pushin = MergeBinTree(temp1, temp2); 45 Q1->tree[i] = NULL; 46 Q2->tree[i] = NULL; 47 break; 48 case 4: //只有进位 49 Q1->tree[i] = pushin; 50 pushin = NULL; 51 break; 52 case 5: //有Q1和进位,但无Q2 53 pushin = MergeBinTree(temp1, pushin); 54 Q1->tree[i] = NULL; 55 break; 56 case 6: //有Q2和进位,但无Q1 57 pushin = MergeBinTree(temp2, pushin); 58 Q2->tree[i] = NULL; 59 break; 60 case 7: //三者都有,任选一个即可 61 pushin = MergeBinTree(temp2, pushin); 62 Q2->tree[i] = NULL; 63 break; 64 } 65 } 66 return Q1; 67 }
2、插入(Insert):既然合并是$O(log N)$的,插入则以一次合并完成即可。后面会介绍到,插入的摊还时间复杂度可以达到$O(1)$。
3、建立二项队列(Build):从单个数或者单个二项树建立二项队列的方法是平凡的。从一个数组开始建立二项队列的方法就是$N$次插入或者$N$次合并。之后会分析到,这样操作的时间复杂度是$O(N)$。下面是一种可行的实现:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 BinQueue* BuildBinQueue(int A[], int size) { 2 //从数组建二项队列,进行n次合并即可 3 BinQueue* Q = BuildBinQueue_NULL(); 4 if(size<=0) 5 return Q; 6 7 Q->size = 1; 8 Q->tree[0] = BuildBinTreeNode(A[0]); 9 BinQueue* tQ = BuildBinQueue_NULL(); 10 tQ->size = 1; 11 for (int i = 1; i < size; i++) { 12 tQ->tree[0] = BuildBinTreeNode(A[i]); 13 Q=MergeBinQueue(Q,tQ); 14 } 15 return Q; 16 }
4、找到堆顶(FindMin):二项树是满足堆序的,但二项队列不记录整体的堆序,从而找到堆顶需要遍历二项树的堆顶,时间复杂度是$O(log N)$。某种实现如下:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 BinTree* FindMin(BinQueue* Q) { 2 //找到最小元 3 if (Q->size <= 0) { 4 printf("Finding error: empty "); 5 return NULL; 6 } 7 BinTree* res = NULL; 8 int minval = 0x7ffffff7; 9 10 for (int i = 0, j = 1; j <= Q->size; i++, j <<= 1) { 11 if (Q->tree[i] == NULL) 12 continue; 13 14 if (Q->tree[i]->val < minval) { 15 minval = Q->tree[i]->val; 16 res = Q->tree[i]; 17 } 18 } 19 return res; 20 }
5、删除堆顶(Pop):删除最值只是删除一个结点,它的诸子树并不应该从结构里删除,从而这些子树应该并入二项队列。刚刚介绍到,某棵二项树树根的诸子树也是一个二项队列,从而这一操作也是合并。由于二项树$B_k$有$k-1$棵子树,这样的合并也是$O(log N)$的,从而整体的操作也是$O(log N)$的。某种实现如下:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 void Pop(BinQueue* Q) { 2 //删除最小元,把它的诸儿子合并进二项队列 3 if (Q->size <= 0) 4 return; 5 6 int res = -1; 7 int minval = 0x7fffffff; 8 9 for (int i = 0, j = 1; j <= Q->size; i++, j <<= 1) { 10 if (Q->tree[i] == NULL) 11 continue; 12 13 if (Q->tree[i]->val < minval) { 14 minval = Q->tree[i]->val; 15 res = i; 16 } 17 } 18 19 if (res == -1) { 20 printf("Poping error: cant find top "); 21 return; 22 } 23 24 BinQueue* tQ = BuildBinQueue_NULL(); 25 BinTree* T = Q->tree[res]; 26 tQ->size = (T->size) - 1; 27 BinTree* temp = T->leftSon; 28 29 for (int i = (T->rank) - 1; i >= 0 && temp != NULL; i--) { 30 tQ->tree[i] = temp; 31 temp = temp->rightBro; 32 } 33 34 Q->tree[res] = NULL; 35 (Q->size) -= T->size; 36 delete T; 37 Q = MergeBinQueue(Q, tQ); 38 return; 39 }
6、其它操作:如果我们能找到需要修改的结点的位置,那么减小键值只要像二叉堆一样向上过滤就好,不过这需要我们额外保存父指针。删除特定结点只需减小键值使之成为堆顶,再删除堆顶即可。这些操作就不给出实现了。增加键值的消耗是很大的。介绍二项树时提到,高度是$h$的结点的总数是$C_{k}^{h}$,从而向下过滤的最坏复杂度是$O(N)$。
三、二项队列的分析
1、二项队列的很多操作的分析都很简单,但插入和建堆的操作的确切的界并不好分析,这需要我们用上摊还分析。
首先我们应该找到位势函数,为此,我们来看看一次插入会发生什么:
假如向一个二项队列$Q$里插入一个结点。如果$Q$没有$B_0$,自然,这个结点就成为了$B_0$;否则,两个二项树就需要合并,成为了一个$B_1$,如果$Q$没有$B_1$,插入也结束了,但如果有,则还要合并然后进位。
很显然,如果$Q$拥有从$0$到$k$之间所有二项树,但没有$B_{k+1}$,那么每个二项树都会被合并,最后成为了一棵$B_{k+1}$,然后插入结束。显然,这次插入花费的时间$T = k$。这样,最坏的情况当然是$O(log N)$。不过很有意思的是,如果$Q$拥有每种二项树,那么一次插入后,它就只剩下一棵最大的二项树了。
如果一次插入花费了$k$次合并,那么最后$Q$就少了原本的$k$棵树,然后多了一棵$B_{k+1}$。我们考虑用$Q$中二项树的棵数做位势函数:
若$T=k$,则$Delta phi = 1-k$。另外,显然任意时刻$phi > 0$,而二项队列未建立时$phi_0 = 0$,从而这个位势函数指示了时间复杂度的一个上界。进而一次插入的均摊时间$T^*$满足:
$T^* = T + Delta phi = 1$
从而单次插入的$O(1)$复杂度就得到了证明。
建堆执行$N$次插入(也就是$N$次合并),它的均摊时间复杂度自然是:
$T_{1}^{*} = T_1 + (phi_1 - phi_0)$
$T_{2}^{*} = T_2 + (phi_2 - phi_1)$
$...$
$T_{N}^{*} = T_{N} + (phi_N - phi_{N-1})$
加上前面得到的单次公式$T^* = T + Delta phi = 1$,得到:
$sum T^* = N$
进而建堆的均摊复杂度就是$O(N)$。
可以看到,这个位势函数非常优秀,它使得单次均摊时间居然是一个常数。因此,二项队列是摊还分析的一个经典而简单的例子,比斜堆更简单,分析斜堆时,我们还额外去证明单次均摊时间的上界。
2、虽然插入和建堆用上摊还分析后,时间已经得到证明,而且这个位势函数极其优秀,但是我们还应该照顾到可能改变位势的其它操作。合并操作,由于合并后队列里至多有$O(log N)$个树,从而位势的改变也至多是$O(log N)$的,从而它的均摊时间也是$O(log N)$;删除堆顶是同样的分析。进而,在这个位势函数下,其它操作的复杂度也没有改变。
以上就是二项队列的实现以及复杂度分析。值得注意的是,在时间复杂度上它已经足够优越,但是空间复杂度上明显不如二叉堆。