竞赛树：
tournament tree, 也是以可完全二叉树，所以使用数组描述效率最好，竞赛树的基本操作是替换最大(小)元素
赢者树和输者树：
为了便于实现，需要将赢者树限制为完全二叉树。n个参与者的赢者树，具有n个外部节点，n-1个内部节点。每个内部节点记录的是在该节点比赛的赢者。
最大赢者树和最小赢者树：
为了确定输赢者，给每个选手一个分数，分数最大挥着最小的获胜，称为最大最小赢者树：
赢者树的初始化：
采用二叉树的后序遍历方法。每遍历一个节点，就相当于进行一场比赛。
排序：
内部排序法： 例如堆排序，插入排序，需要将排序的元素全部放入计算机内存进行排序，但是当待排序的元素数量超出内存的大小时，就需要使用外部排序。
外部排序步骤：
1. 生成一些初始的归并段（有序的部分待排序元素）
2. 合并这些归并段（利用赢者树）
C++实现赢者树：
假设用完全二叉树的数组表示赢者树，一棵赢者树有n个选手，则需要n-1个内部节点tree[1:n-1]，选手用数组player[1:n]表示。因此tree[i]是数组player的一个索引。
因此，必须确定外外部节点player[i]的父节点tree[P]。
选手个数n,内部节点个数n-1,最底层最左端的内部节点编号为2^s,其中s = 【log2(n-1)】, 最底层内部节点的个数n-s.最底层外部节点的个数lowExt = 2*(n-s),取offset = 2*s-1.则对于任何一个外部节点player[i], 其父节点tree[P]由以下公式给出：
赢者树的初始化：
为了初始化赢者树，需要从右孩子选手开始，进行他们所参加的比赛，而且逐层往上，只要是右孩子上升到比赛节点，就可以进行比赛。如在上图中，先进性p[2]的比赛，在进行p[3]的比赛得到结果t[2]，但是t[2]的比赛不能进行，因为它是左孩子，所以需要进行p[5]的比赛，得到t[3]，t[3]是右孩子，进行t[3]的比赛，得到t[1];
重新组织比赛：
当选手theplayer的值发生变化时，从外部节点player[theplayer]到根tree[1]的路径上，一部分或全部比赛都要重赛。
竞赛树的实现代码：
#ifndef TOURNAMENT_TREE_H
#define TOURNAMENT_TREE_H
#include <iostream>
#include <cmath>
using namespace std;
template<class T>
class completeWinnerTree
{
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");
cout << "The players must > 2" << endl;
exit(0);
}
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)//改变的选手必须要在范围内。
{
cout << "Invalid index" << endl;
exit(0);
}
//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];
}
template<typename T>
void completeWinnerTree<T>::output() const
{
cout << "number of players: " << numberOfPlayers << endl;
cout << "lowExt = " << lowExt << endl;
cout << "offset = " << offset << endl;
for(int i=1; i<numberOfPlayers; i++)
{
cout << tree[i] << " ";
}
cout << endl;
}
#endif
代码来源：https://www.cise.ufl.edu/~sahni/dsaac
搜索树
搜索树适用于字典描述，与跳表和散列相比，二叉搜索树和平衡搜索树使用更加灵活，在最坏的情况下性能有保证。
二叉搜索树：
是一棵二叉树，可能为空，非空的二叉搜索树满足以下特征：
1.每个元素都有唯一的关键字
2.根节点的左子树中，元素的关键字都小于根节点的关键字
3.根节点的右子树中，元素的关键字都大于根节点的关键字
4.根节点左右子树也都是二叉搜索树
a就不是二叉搜索树（不满足4），bc是二叉搜索树。
注： 有重复值的二叉搜索树， 小于-->小于等于
索引二叉搜索树：
源于普通的二叉搜索树，只是在每个节点中添加一个leftSize域，表示该节点的左子树的元素个数：
二叉搜索树的操作：
1. 搜索：
假设需要查找的关键字为theKey,则先从根节点开始查找，如果为空，则树不包含任何元素；否则，将theKey和根节点的关键字进行比较，如果等于，则查找成功，如果theKey小于根节点的关键字，则查找左子树即可，否则，查找右子树。
2. 插入
假设要在二叉搜索树中插入一个元素，首先通过查找来确定，要插入的元素的关键字在树中是否存在，如果存在，则用插入元素的value覆盖掉原来的value，否则，将元素插入树中：
3. 删除
要考虑三种情况：
1.要删除的节点是树叶：
2.要删除的节点有一棵子树
3.要删除的节点有两棵子树
二叉搜索树的实现;
// 定义二叉搜索树树
#ifndef BSTREE_H
#define BSTREE_H
#include <algorithm>
#include <iostream>
using namespace std;
// 定义二叉搜索树的节点
template<typename K=int, typename V=int> // key: value类型的节点
struct BSTreeNode
{
BSTreeNode* leftchild;
BSTreeNode* rightchild;
K key;
V value;
BSTreeNode(K& theKey, V& theValue)
{
key = theKey;
value = theValue;
leftchild = NULL;
rightchild = NULL;
}
};
template<typename K, typename V>
class BSTree
{
typedef BSTreeNode<K, V> BSTreeNode;
private:
BSTreeNode* root; // 二叉搜索树的根节点
int treeSize;
void destory(BSTreeNode* mroot); // 删除二叉树的所有节点 // 析构函数
BSTreeNode* find(K theKey, BSTreeNode* mroot);
void insert(K theKey, V theValue, BSTreeNode* mroot);
void remove(K theKey, BSTreeNode* mroot); // 删除特定的节点
void out_put(BSTree* mroot);
public:
BSTree();
~BSTree();
// void destory();
// 查找二叉树的节点
BSTreeNode* find(K theKey); // 参数：键值
void insert(K theKey, V theValue);
void remove(K theKey);
void out_put();
};
template<typename K, typename V>
void BSTree<K, V>::destory(BSTreeNode* mroot)
{
// 删除所有节点 递归调用
if(mroot!=NULL)
{
destory(mroot->leftchild);
destory(mroot->rightchild);
delete mroot;
}
}
template<typename K, typename V>
BSTree<K, V>::BSTree()
{
treeSize = 0;
root = NULL;
}
template<typename K, typename V>
BSTree<K, V>::~BSTree()
{
// 删除二叉树的节点
destory(root);
}
template<typename K, typename V>
BSTreeNode* BSTree<K, V>::find(K theKey)
{
// 二叉搜索树的查找函数
// 根据关键字查找：
return find(theKey, root);
}
template<typename K, typename V>
BSTreeNode* BSTree<K, V>::find(K theKey, BSTreeNode* mroot)
{
if(mroot != NULL)
{
if(mroot->key==theKey)
{
return mroot;
}
else if(mroot->key>theKey) // 搜索左子树
{
return find(theKey, mroot->leftchild); // 递归的方法
}
else // 搜索右子树
{
return find(theKey, mroot->rightchild);
}
}
return NULL; // 没有找到
}
template<typename K, typename V>
void BSTree<K, V>::insert(K theKey, V theValue, BSTreeNode* mroot)
{
// NULL
if(mroot==NULL)
{
mroot = new BSTreeNode(theKey, theValue);
return; // 递归结束
}
if(mroot->key==theKey) // 关键字已经存在
{
mroot->value = theValue;
return; // 结束递归
}
else if(theKey < mroot->key) // 插入左子树
{
insert(theKey, theValue, mroot->leftchild);
}
else // 插入右子树
{
insert(theKey, theValue, mroot->rightchild);
}
}
template<typename K, typename V>
void BSTree<K, V>::insert(K theKey, V theValue)
{
insert(theKey, theValue, root);
}
template<typename K, typename V>
void BSTree<K, V>::remove(K theKey, BSTreeNode* mroot)
{
/*
if(mroot==NULL) // 结束的条件
{
cout << "No such node" << endl;
return;
}
*/
// 只有一个节点
if(mroot->leftchild==NULL && mroot->rightchild==NULL) // 最底层的节点
{
if(root->key==theKey) // 是要查找的节点
{
delete mroot;
mroot = NULL;
return;
}
}
if(theKey<mroot->key) // 搜索左子树
{
remove(theKey, mroot->leftchild);
}
else if(theKey>mroot->key)
{
remove(theKey, mroot->rightchild); // 搜索右子树
}
else // 相等。且不是最底层的节点
{
BSTreeNode* del = NULL; // 临时的指针
if(mroot->leftchild==NULL) // 只有右孩子
{
del = mroot;
mroot = mroot->rightchild; // 取右孩子
delete del;
del = NULL;
return;
}
else if(mroot->rightchild==NULL) // 只有左孩子
{
del = mroot;
mroot = mroot->leftchild;
delete del;
del = NULL;
return;
}
else // 要删除的节点有左右子树
{
BSTreeNode* rightFirst = mroot->rightchild; // 获取要删除的节点的右孩子
while(rightFirst->leftchild!=NULL)
{
rightFirst = rightFirst->leftchild;
}
// 交换
// 将要删除的节点交换到最底层
swap(mroot->key, rightFirst->key);
swap(mroot->value, rightFirst->value);
remove(theKey, mroot->rightchild); // 接着删除
return; // ?
}
}
}
template<typename K, typename V>
void BSTree<K, V>::remove(K theKey)
{
remove(theKey, root);
}
template<typename K, typename V>
void BSTree<K, V>::out_put(BSTreeNode* mroot)
{
if(mroot==NULL)
{
return;
}
out_put(mroot->leftchild);
cout << "key: " << mroot->key << " value: " << mroot->value << " ";
out_put(mroot->rightchild);
}
template<typename K, typename V>
void BSTree<K, V>::out_put()
{
out_put(root);
}
#endif