胜者树与败者树

最新推荐文章于 2023-08-14 11:38:05 发布

yingsun

最新推荐文章于 2023-08-14 11:38:05 发布

阅读量3.3k

点赞数

分类专栏：树

本文链接：https://blog.csdn.net/zzran/article/details/8273584

版权

树专栏收录该内容

18 篇文章 0 订阅

订阅专栏

胜者树和败者树都是完全二叉树，是树形选择排序的一种变型。每个叶子结点相当于一个选手，每个中间结点相当于一场比赛，每一层相当于一轮比赛。不同的是，胜者树的中间结点记录的是胜者的标号；而败者树的中间结点记录的败者的标号。

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

胜者树的一个优点是，如果一个选手的值改变了，可以很容易地修改这棵胜者树。只需要沿着从该结点到根结点的路径修改这棵二叉树，而不必改变其他比赛的结果。下面是选择一个最小的数字为最胜利者（见图1所示），第一次把各个数组里面的第一个元素都放进去，这是根据胜利树的规则两两比较，得到最小的值，第一次弄完之后，就得出1数字是胜利的，也就是1是最小的。在下一次输出第二小的数字时候，只需要把1所在的数组里面的元素加进去，然后从叶子节点到根节点一直比较得出第二小的值，这样就减少了很多次无用的比较（见图2所示）。

问题：有20个有序数组，每个数组有500个uint变量，降序排序。要求从这10000个元素中选出最大的500个。

有人可能会有疑问，就是如果给定的是奇数个数组，那么这个胜者树是不是不能用了呢，其实是可以的。我们大不了可以加一个数组，把数组的个数凑成偶数。这个新加的数组中的所有元素置为极大值或者极小值。这样，这些元素虽然被构建到胜者树中，但是他们因为是极大或者极小的，所以不被纳入胜者树的计算结果中。所以不会产生影响。这样是比较浪费点空间。如果觉得不想浪费这么多的空间，其实还有个办法，那就是在构建胜者树的时候考虑奇偶。如果x是偶数，那么就分配2*x的空间，把 x-2x-1的元素都赋值。而第0个空间是不用的。第一个空间存储胜者树的根。如果是奇数的情况，算一下要用的节点数。2*(x + 1) - 1个，所以直接分配 2 *（ x + 1）个节点，把最后一个节点的值置为最大或者最小。下面给出程序代码：

#include<iostream>
#include<ctime>
#include<cmath>
#include<algorithm>
using namespace std;
#define INF 100000
#define N 10
typedef struct node{
	int data;
	int index;
	int which;
}Node;
int com(const void *a, const void *b){  
    if(*(int *)a > *(int *)b){  
        return 1;  
    }else if(*(int *)a < *(int *)b){  
        return -1;  
    }   
    return 0;  
}  
void adjustTreeForFirst(Node *tempArray, int len) {
	int i = len / 2;
	int j;
	while(i > 1) { //第0个单元不会用到，第一个为树的根
		for(j = i; j < (2*i-1); j += 2) {
			if(tempArray[j].data < tempArray[j+1].data) {
				tempArray[j / 2] = tempArray[j];
			} else {
				tempArray[j / 2] = tempArray[j+1];
			}
		}
		i /= 2;
	}
}
void get_data(int **a, int row, int col, int len) {
	int *result = new int[len];
	memset(result, 0, sizeof(int) * len);
	int i,j;
	Node *temp = new Node[row * 2];
	for(i = 0; i < row; i++) {
		temp[row + i].which = i;
		temp[row + i].index = 0;
		temp[row + i].data = a[i][0];
	}
	for(j = 0; j < len; j++) {
		adjustTreeForFirst(temp, 2 * row);
		result[j] = temp[1].data;
		if(temp[1].index + 1 < col) {
			temp[row + temp[1].which].data = a[temp[1].which][temp[1].index + 1];
			temp[row + temp[1].which].index = temp[1].index + 1;
			temp[row + temp[1].which].which = temp[1].which;
		} else {
			temp[row + temp[1].which].data = INF;
		}
	}
	cout << "required data:" << endl;
	for(i = 0; i < len; i++){  
        cout << result[i] << "\t";  
    }  
	delete []result;
	delete []temp;
}
int main() {
	const int row = 9;  
    const int col = 10;  
   
    int *a[row];  
    int i = 0, j = 0;  
    //分配内存空间   
    for(i = 0; i < row; i++){  
        a[i] = (int *)malloc(col * sizeof(int));     
    }  
      
    //初始化数组   
	cout << "raw data:" << endl;
    srand( time(NULL) );   
    for(i = 0; i < row; i++){  
        for(j = 0; j < col; j++){  
            a[i][j] = rand() % 300;
			cout << a[i][j] << "\t";
        }
    }  
    //排序   
	
    for(i = 0; i < row; i++){  
        qsort(a[i], col, sizeof(int), com);  
    }  
	get_data(a, row, col, 40);
	return 0;
}

败者树：

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