赢者树：有n个选手的一颗赢者树是一颗完全二叉树，它由n个外部节点和n-1个内部节点，每个内部节点记录的是在该节点比赛的赢者。
简单的说就是有一颗完全二叉树，从叶节点开始，左右两个子节点谁大（小），就把谁的值赋值给他们的父节点，然后父节点在和其兄弟节点进行比较将较大（小）者赋值给其父节点直到根节点，那么根节点的数据就是冠军。
注意：现实的竞赛所对应的树不一定都是完全二叉树，但是用完全二叉树能使比赛的场次最少。
赢者树实现原理：
假如用完全二叉树的数组表示来表示赢者树。一颗赢者树有n名选手，需要n-1个内部节点tree[1:n-1]。选手（或外部节点）用数组palyer[1:n]表示，因此tree[i]是数组player的一个索引，类型为int。在赢者树的节点i对应比赛中，tree[i]代表赢者，为实现这种对应关系，我们必须能够确定外部节点player[i]的父节点tree[p]。当外部节点的个数为n时，内部节点的个数为n-1。最底层最左端的内部节点，其编号为s，且s=2^[log2(n-1)] (这里中括号代表向下取整)。因此，最底层内部节点的个数是n-s，最底层外部节点个数lowExt是这个数的2倍。倒数第二层最左端的外部节点号为lowExt+1。令offset=2*s-1。对于任何一个外部节点player[i]，其父节点tree[p]由以下公式给出：
(i+offset)/2 i<=lowExt.
p=
(i-lowExt+n-1)/2 i>lowExt
赢者树的初始化：
我们计算比赛时是从左往右，所以当当前计算的节点为某个父节点的右子节点时，我们就能组织一场比赛，因为左节点的胜者一定产生了，否则不会轮到右节点，我们是从左往右开始计算的。
// node type used by winner tree
#ifndef player_
#define player_
struct player
{
int id, key;
operator int () const {return key;}
};
#endif
// abstract class winner tree
// all methods are pure virtual functions
#ifndef winnerTree_
#define winnerTree_
using namespace std;
template<class T>
class winnerTree
{
public:
virtual ~winnerTree() {}
virtual void initialize(T *thePlayer, int theNumberOfPlayers) = 0;
// create winner tree with thePlayer[1:numberOfPlayers]
virtual int winner() const = 0;
// return index of winner
virtual void rePlay(int thePLayer) = 0;
// replay matches following a change in thePLayer
};
#endif
以上是winnertree的虚类。
#ifndef completeWinnerTree_
#define completeWinnerTree_
#include <iostream>
#include "winnerTree.h"
#include "myExceptions.h"
template<class T>
class completeWinnerTree : public winnerTree<T>
{
public:
completeWinnerTree(T *thePlayer, int theNumberOfPlayers)
{
tree = NULL;
initialize(thePlayer, theNumberOfPlayers);
}
~completeWinnerTree() {delete [] tree;}
void initialize(T*, int);
int winner() const//返回赢者树的根节点。
{return tree[1];}
int winner(int i) const//返回第i个节点的胜者
{return (i < numberOfPlayers) ? tree[i] : 0;}
// return winner of match at node i
void rePlay(int);
void output() const;
private:
int lowExt; // lowest-level external nodes
int offset; // 2^log(n-1) - 1
int *tree; // array for winner tree
int numberOfPlayers;
T *player; // array of players
void play(int, int, int);
};以上是主类。
template<class T>
void completeWinnerTree<T>::play(int p, int leftChild, int rightChild)
{// play matches beginning at tree[p]
// leftChild is left child of p
// rightChild is right child of p
//如果左节点的数据较小则左节点晋级。
tree[p] = (player[leftChild] <= player[rightChild]) ?
leftChild : rightChild;
// more matches possible if at right child
while (p % 2 == 1 && p > 1)//如果当前节点是右节点，且不是根节点，那么继续进行比赛。
{// at a right child
tree[p / 2] = (player[tree[p - 1]] <= player[tree[p]]) ?
tree[p - 1] : tree[p];
p /= 2; // go to parent
}
}以上为每次比赛的函数，父节点指向子节点中胜者的索引，如果父节点依然是其父节点的右节点，那么继续组织下一场的比赛，直到节点到根节点，或者为左节点为止。
template<class T>
void completeWinnerTree<T>::initialize(T *thePlayer,
int theNumberOfPlayers)
{// Create winner tree for thePlayer[1:numberOfPlayers].
//比赛参与者最少2个人否则报错
int n = theNumberOfPlayers;
if (n < 2)
throw illegalParameterValue("must have at least 2 players");
player = thePlayer;//获取外节点数组。
numberOfPlayers = n;
delete [] tree;//初始化树节点，因为第0位置不放数据，所以实际大小为n-1.
tree = new int [n];//
// compute s = 2^log (n-1)
int i, s;//计算内部节点最左边的节点编号，下面采取寻访方式计算s，非常巧妙
for (s = 1; 2 * s <= n - 1; s += s);
lowExt = 2 * (n - s);//计算最低层外部节点的个数
offset = 2 * s - 1;
// play matches for lowest-level external nodes
for (i = 2; i <= lowExt; i += 2)//首先进行最底层外部节点的比赛，i从2开始且每次+2是为了每次都是从右子节点开始进行比赛
play((offset + i) / 2, i - 1, i);
// handle remaining external nodes
if (n % 2 == 1)//如果倒数第二层最左边的元素为某个父节点的右节点，则进行如下处理，即比赛。
{// special case for odd n, play internal and exteral node
play(n/2, tree[n - 1], lowExt + 1);
i = lowExt + 3;//然后从lowExt+3即倒数第二层外部节点的右儿子开始比赛
}
else i = lowExt + 2;//否则右儿子为lowExt+2
// i is left-most remaining external node
for (; i <= n; i += 2)//然后开始处理倒数第二层其他外部节点。
play((i - lowExt + n - 1) / 2, i - 1, i);//play每次都会处理到上层的左节点为止，然后再去处理下一个右节点。
}以上是赢者树的初始化代码，首先处理最下层外部节点，然后倒数第二层与倒数低层的交界处，然后倒数第二层的其他外部节点。
template<class T>
void completeWinnerTree<T>::rePlay(int thePlayer)
{// Replay matches for player thePlayer.
int n = numberOfPlayers;
if (thePlayer <= 0 || thePlayer > n)//改变的选手必须要在范围内。
throw illegalParameterValue("Player index is illegal");
int matchNode, // node where next match is to be played需要重赛的父节点
leftChild, // left child of matchNode该父节点的左孩子
rightChild; // right child of matchNode右孩子
// find first match node and its children
if (thePlayer <= lowExt)//如果改变的参数在最低层
{// begin at lowest level
matchNode = (offset + thePlayer) / 2;//要求重赛的父节点
leftChild = 2 * matchNode - offset;//及其子节点
rightChild = leftChild + 1;
}
else
{
matchNode = (thePlayer - lowExt + n - 1) / 2;//如果要求重赛的选手在倒数第二层的外部节点。
if (2 * matchNode == n - 1)//如果要求重赛的选手在倒数第二层与倒数第一层的交界点处
{
leftChild = tree[2 * matchNode];
rightChild = thePlayer;
}
else//否则在倒数第二层的外部节点处。
{
leftChild = 2 * matchNode - n + 1 + lowExt;
rightChild = leftChild + 1;
}
}
tree[matchNode] = (player[leftChild] <= player[rightChild])//重赛
? leftChild : rightChild;
// special case for second match
if (matchNode == n - 1 && n % 2 == 1)//这里没弄明白。。。
{
matchNode /= 2; // move to parent
tree[matchNode] = (player[tree[n - 1]] <=
player[lowExt + 1]) ?
tree[n - 1] : lowExt + 1;
}
// play remaining matches
matchNode /= 2; // move to parent
for (; matchNode >= 1; matchNode /= 2)//依次往上进行重赛直到主节点。
tree[matchNode] = (player[tree[2 * matchNode]] <=
player[tree[2 * matchNode + 1]]) ?
tree[2 * matchNode] : tree[2 * matchNode + 1];
}
以上为重赛代码，其中有一句一直没弄明白。