胜者树和败者树

点点圈 提交于 2020-03-25 14:54:40

      胜者树和败者树都是完全二叉树,是树形选择排序的一种变型。每个叶子结点相当于一个选手,每个中间结点相当于一场比赛,每一层相当于一轮比赛。

      不同的是,胜者树的中间结点记录的是胜者的标号;而败者树的中间结点记录的败者的标号。

       胜者树与败者树可以在log(n)的时间内找到最值。任何一个叶子结点的值改变后,利用中间结点的信息,还是能够快速地找到最值。在k路归并排序中经常用到。

一、胜者树

       胜者树的一个优点是,如果一个选手的值改变了,可以很容易地修改这棵胜者树。只需要沿着从该结点到根结点的路径修改这棵二叉树,而不必改变其他比赛的结果。

Fig. 1

Fig.1是一个胜者树的示例。规定数值小者胜。

  1. b3 PK b4,b3胜b4负,内部结点ls[4]的值为3;
  2. b3 PK b0,b3胜b0负,内部结点ls[2]的值为3;
  3. b1 PK b2,b1胜b2负,内部结点ls[3]的值为1;
  4. b3 PK b1,b3胜b1负,内部结点ls[1]的值为3。.

当Fig. 1中叶子结点b3的值变为11时,重构的胜者树如Fig. 2所示。

  1. b3 PK b4,b3胜b4负,内部结点ls[4]的值为3;
  2. b3 PK b0,b0胜b3负,内部结点ls[2]的值为0;
  3. b1 PK b2,b1胜b2负,内部结点ls[3]的值为1;
  4. b0 PK b1,b1胜b0负,内部结点ls[1]的值为1。.

Fig. 2

用胜者树对n个节点实现排序操作,构建胜者树和构建堆比较相似,区别在于胜者树只有叶子节点存放了数据,中间节点记录的是叶子节点间的关系。

leaves[n+1]:共有n个叶子节点,存储下标从1到n

successTree[n]:存储中间节点,存储下标从1到n-1

对successTree中的数据从n-1到1,按照优胜策略不断调整内部节点的数值,最后得到一颗胜者树

冠军节点的下标存储在successTree[1]里,实现排序操作时,将该叶子节点的值打印输出,并用一个比叶子节点中所有值都大的值MAX替换,然后对树进行调整。胜者树的调整是从叶子节点到根节点的自下而上的调整,每次都比较双亲节点的左右孩子节点,并把优胜者的下标志存储在双亲节点中。

 1 #include <stdio.h>
 2 #define K 10
 3 #define MAX 65535
 4 int leaves[K+1];
 5 int successTree[K];
 6 
 7 /* 对于单个内部节点进行调整 */
 8 void adjust(int i)
 9 {
10     int m,n;
11     if(2 * i < K)               /* 获取它的左孩子结点 */
12         m = successTree[2 * i];
13     else
14         m = 2 * i - K + 1;
15     if(2*i+1<K)                 /* 获取它的右孩子节点 */
16         n = successTree[2*i+1];
17     else
18         n = 2 * i + - K + 2;
19     successTree[i] = leaves[m] > leaves[n] ? n : m; /* 进行胜负判定 */
20 }
21 /* 初始化叶子节点并对内部节点进行类似于堆的调整 */
22 void initTree()
23 {
24     for(int i=1;i<K+1;i++)
25         scanf("%d", &leaves[i]);
26     for(int i=K-1;i>0;i--)
27         adjust(i);
28 }
29 /* 自下而上对胜者树进行调整 */
30 void adjustToRoot(int i)
31 {
32     int parent = (i + K - 1) / 2; /* 对从当前节点到根节点路径上的所有
33                                    * 节点进行调整 */
34     while(parent>0)
35     {
36         adjust(parent);
37         parent = parent / 2;
38     }
39 }
40 
41 int main()
42 {
43     freopen("in","r",stdin);
44     initTree();
45     for(int i=1;i<K+1;i++)      /* 每次用最大值替换掉冠军节点,并对树
46                                  * 进行调整,最终得到升序排序的序列 */
47     {
48         printf("%d ", leaves[successTree[1]]);
49         leaves[successTree[1]]=MAX;
50         adjustToRoot(successTree[1]);
51     }
52     return 0;
53 }

 

二、败者树

       败者树是胜者树的一种变体。在败者树中,用父结点记录其左右子结点进行比赛的败者,而让胜者参加下一轮的比赛。败者树的根结点记录的是败者,需要加一个结点来记录整个比赛的胜利者。采用败者树可以简化重构的过程。

Fig. 3

Fig. 3是一棵败者树。规定数大者败。

  1. b3 PK b4,b3胜b4负,内部结点ls[4]的值为4;
  2. b3 PK b0,b3胜b0负,内部结点ls[2]的值为0;
  3. b1 PK b2,b1胜b2负,内部结点ls[3]的值为2;
  4. b3 PK b1,b3胜b1负,内部结点ls[1]的值为1;
  5. 在根结点ls[1]上又加了一个结点ls[0]=3,记录的最后的胜者。

败者树重构过程如下:

  • 将新进入选择树的结点与其父结点进行比赛:将败者存放在父结点中;而胜者再与上一级的父结点比较。
  • 比赛沿着到根结点的路径不断进行,直到ls[1]处。把败者存放在结点ls[1]中,胜者存放在ls[0]中。

Fig. 4

       Fig. 4是当b3变为13时,败者树的重构图。

       注意,败者树的重构跟胜者树是不一样的,败者树的重构只需要与其父结点比较,而胜者树则需要和兄弟节点比较。对照Fig. 3来看,b3与结点ls[4]的原值比较,ls[4]中存放的原值是结点4,即b3与b4比较,b3负b4胜,则修改ls[4]的值为结点3。同理,以此类推,沿着根结点不断比赛,直至结束。

        败者树常常用于多路外部排序,对于K个已经排好序的文件,将其归并为一个有序文件。败者树的叶子节点是数据节点,两两分组,内部节点记录左右子树中的“败者”,优胜者往上传递一直到根节点,如果规定优胜者是两个数中的较小者,则根节点记录的是最后一次比较中的败者,也就是第二小的数,而用一个变量来记录最小的数。把最小值输出以后,用一个新的值替换最小值节点的值(在文件归并的时候,如果文件已经读完,可以用一个无穷大的数来替换),接下来维护败者树,从更新的节点往上,一次与父节点比较,将败者更新,胜者继续比较。

        注意:当叶子节点的个数变动的时候需要完全重新构建整棵树。

       比较败者树和堆的性能

       败者树在维护的时候,比较次数是logn+1,  败者树从下往上维护,每上一层,只需要和父节点比较一次,而堆是自上往下维护,每一层需要和左右子节点都比较,需要比较两次,从这个角度,败者树比堆更优一点,但是,败者树每一次维护,必然是从叶子节点到根节点的一条路径,而堆维护的时候有可能在中间某个层次停止,这样败者树虽然每层比堆比较的次数少,但是堆比较的层数可能比较少。

        

       从n个数中找出最大的k个,分别用堆和败者树来实现

       堆实现: 维护一个大小为k的小顶堆,每来一个数都和堆顶进行比较,如果比堆顶小,直接舍弃,否则替换堆顶,维护堆,直到n个数都处理完毕,时间复杂度为O(nlogk)

 

       败者树实现:当用数组来实现败者树时, 维护一个叶子节点个数为k的败者树,注意是叶子节点个数而不是所有节点个数,数字较小者取胜,则最顶层保存的是值最小的叶子节点,每来一个数和最小值比较,如果比最小值还小,直接舍弃,否则替换最小值的节点值,从下往上维护败者树,最后的k个叶子节点中保存的就是所有数中值最大的k的,时间复杂度为O(nlogk)

     

       用数组实现败者树的时候,因为只有叶子节点存储的是数据,因此败者树使用的内存空间是堆的两倍。

       完全树的内部,度数为2的节点个数是叶子节点个数减一 ,所以使用的数组大小为2k-1, 如果把最值也存入数组中,则需要的数组大小为2k

 

       败者树的构造

       思路: 先构造一颗空的败者树,然后把叶子节点一个一个的插入败者树,自底向上不断的调整,保持内部节点保存的都是失败者的节点编号,优胜者一直向上不断比较,最终得到一颗合格的败者树。

 

leaves[K+1] : 叶子节点的个数为K,下标从1到K,下标0处存储一个最小值,用来初始化败者树

loserTree[K]: 冠军节点存储在下标0,下标1到K-1存储内部节点

int loserTree[K];               /* 存储中间节点值,下标0处存储冠军节点 */
int leaves[K+1];                /* 从下标1开始存储叶子节点值,下标0处存储一个最小值节点 */

void adjust(int i)
{
    int parent=(i+K-1)/2;      /* 求出父节点的下标 */
    while(parent>0)
    {
        if(leaves[i]>leaves[loserTree[parent]])
        {
            int temp=loserTree[parent];
            loserTree[parent]=i;
            /* i指向的是优胜者 */
            i= temp;
        }
        parent = parent / 2;
    }
    loserTree[0]=i;
}

void initLoserTree()
{
    int i;
    for(i=1;i<K+1;i++)
        scanf("%d",&leaves[i]);
    leaves[0]=MIN;
    for(int i=0;i<K;i++)
        loserTree[i]=0;
    for(int i=K;i>0;i--)
        adjust(i);
}

 

     

标签
易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!