数据结构与算法复习——6、二项队列及其分析

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}$，这也明确地告诉我们，它的诸子树也算一个二项队列。不过，这个二项队列我们不需要快速找到每棵子树，而只需要在树根被删除时提取出来（下面会介绍到），同时它的每个位置又都有二项树，从而用一个链表是更合适的选择。

从而，二项队列里的一棵二项树的子树的存储方式就应该是一个链表（也就是表头），另外每个二项树结点自己也有可能是链表上的结点，从而也要存储链表的后继结点，这样，一个二项树结点的内容就决定了，也就是所谓的“左儿子右兄弟”的原则。二项树和二项队列的声明如下：

struct BinTree {
    int val;           //键值
    int rank;          //秩
    int size;          //树的大小
    BinTree* leftSon;  //最左侧的儿子
    BinTree* rightBro;
    //右兄弟，链表存储二项树的儿子们
};

struct BinQueue {
    int size;           //队列的大小
    BinTree* tree[21];  //二项队列的各项
};

现在，我们来介绍二项队列作为优先队列的一些操作以及实现。以维持小根为例。

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)$的。二项树的合并、二项队列的合并的一种实现如下：

BinTree* MergeBinTree(BinTree* T1, BinTree* T2) {
    //合并二项树
    if (T1->rank != T2->rank) {
        printf("TreeMerging error: non same rank
");
        return NULL;
    }  //只有同秩的才允许合并

    if (T1->val > T2->val)  //维持堆序
        return MergeBinTree(T2, T1);

    (T1->rank)++;      //秩增1
    (T1->size) <<= 1;  //大小翻倍
    T2->rightBro = T1->leftSon;
    T1->leftSon = T2;
    //把新儿子（必然是最大的放在最左侧），并维持链表
    return T1;
}

BinQueue* MergeBinQueue(BinQueue* Q1, BinQueue* Q2) {
    //合并两个二项队列
    if (Q1->size + Q2->size >= 1024 * 1024) {  //超限
        printf("QueueMerging error: exceeded
");
        return NULL;
    }

    BinTree *temp1 = NULL, *temp2 = NULL, *pushin = NULL;

    (Q1->size) += (Q2->size);
    int S = Q1->size;
    int cas;
    for (int i = 0, j = 1; j <= S; i++, j <<= 1) {
        temp1 = Q1->tree[i];
        temp2 = Q2->tree[i];
        cas = (!!temp1) + 2 * (!!temp2) + 4 * (!!pushin);
        switch (cas) {  //二进制加法，在某一位上有8种情况
            case 0:     //无秩i树
            case 1:     //只有Q1有秩i树
                break;
            case 2:  //只有Q2有秩i树，转移到Q1上
                Q1->tree[i] = temp2;
                Q2->tree[i] = NULL;
                break;
            case 3:  // Q1、Q2都有但没有进位，则进位并清空Q1、Q2
                pushin = MergeBinTree(temp1, temp2);
                Q1->tree[i] = NULL;
                Q2->tree[i] = NULL;
                break;
            case 4:  //只有进位
                Q1->tree[i] = pushin;
                pushin = NULL;
                break;
            case 5:  //有Q1和进位，但无Q2
                pushin = MergeBinTree(temp1, pushin);
                Q1->tree[i] = NULL;
                break;
            case 6:  //有Q2和进位，但无Q1
                pushin = MergeBinTree(temp2, pushin);
                Q2->tree[i] = NULL;
                break;
            case 7:  //三者都有,任选一个即可
                pushin = MergeBinTree(temp2, pushin);
                Q2->tree[i] = NULL;
                break;
        }
    }
    return Q1;
}

2、插入（Insert）：既然合并是$O(log N)$的，插入则以一次合并完成即可。后面会介绍到，插入的摊还时间复杂度可以达到$O(1)$。

3、建立二项队列（Build）：从单个数或者单个二项树建立二项队列的方法是平凡的。从一个数组开始建立二项队列的方法就是$N$次插入或者$N$次合并。之后会分析到，这样操作的时间复杂度是$O(N)$。下面是一种可行的实现：

BinQueue* BuildBinQueue(int A[], int size) {
    //从数组建二项队列，进行n次合并即可
    BinQueue* Q = BuildBinQueue_NULL();
    if(size<=0)
        return Q;
    
    Q->size = 1;
    Q->tree[0] = BuildBinTreeNode(A[0]);
    BinQueue* tQ = BuildBinQueue_NULL();
    tQ->size = 1;
    for (int i = 1; i < size; i++) {
        tQ->tree[0] = BuildBinTreeNode(A[i]);
        Q=MergeBinQueue(Q,tQ);
    }
    return Q;
}

4、找到堆顶（FindMin）：二项树是满足堆序的，但二项队列不记录整体的堆序，从而找到堆顶需要遍历二项树的堆顶，时间复杂度是$O(log N)$。某种实现如下：

BinTree* FindMin(BinQueue* Q) {
    //找到最小元
    if (Q->size <= 0) {
        printf("Finding error: empty
");
        return NULL;
    }
    BinTree* res = NULL;
    int minval = 0x7ffffff7;

    for (int i = 0, j = 1; j <= Q->size; i++, j <<= 1) {
        if (Q->tree[i] == NULL)
            continue;

        if (Q->tree[i]->val < minval) {
            minval = Q->tree[i]->val;
            res = Q->tree[i];
        }
    }
    return res;
}

5、删除堆顶（Pop）：删除最值只是删除一个结点，它的诸子树并不应该从结构里删除，从而这些子树应该并入二项队列。刚刚介绍到，某棵二项树树根的诸子树也是一个二项队列，从而这一操作也是合并。由于二项树$B_k$有$k-1$棵子树，这样的合并也是$O(log N)$的，从而整体的操作也是$O(log N)$的。某种实现如下：

void Pop(BinQueue* Q) {
    //删除最小元，把它的诸儿子合并进二项队列
    if (Q->size <= 0)
        return;

    int res = -1;
    int minval = 0x7fffffff;

    for (int i = 0, j = 1; j <= Q->size; i++, j <<= 1) {
        if (Q->tree[i] == NULL)
            continue;

        if (Q->tree[i]->val < minval) {
            minval = Q->tree[i]->val;
            res = i;
        }
    }

    if (res == -1) {
        printf("Poping error: cant find top
");
        return;
    }

    BinQueue* tQ = BuildBinQueue_NULL();
    BinTree* T = Q->tree[res];
    tQ->size = (T->size) - 1;
    BinTree* temp = T->leftSon;

    for (int i = (T->rank) - 1; i >= 0 && temp != NULL; i--) {
        tQ->tree[i] = temp;
        temp = temp->rightBro;
    }

    Q->tree[res] = NULL;
    (Q->size) -= T->size;
    delete T;
    Q = MergeBinQueue(Q, tQ);
    return;
}

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)$；删除堆顶是同样的分析。进而，在这个位势函数下，其它操作的复杂度也没有改变。

　　

　　以上就是二项队列的实现以及复杂度分析。值得注意的是，在时间复杂度上它已经足够优越，但是空间复杂度上明显不如二叉堆。