Análise e implementação de código de árvore perdedor de 22 funções
1 O processo de construção da árvore perdida
2 Analise a figura acima A
árvore do perdedor é composta de nós internos e nós folha.
1) Os nós internos referem-se a nós, exceto os nós folha e ls [0];
2) Os nós folha são nós de dados;
se houver K dados, o nó folha é K, e o nó interno é K-1. Porém, no processo de implementação do código, é necessário haver um valor mínimo e um local para armazenar o índice de valor mínimo, e o valor mínimo é armazenado no nó folha; o índice de valor mínimo é armazenado em ls [0]. Portanto, o comprimento da matriz de nós de dados é K + 1; o comprimento do nó interno é K.
Q1: Por que o nó de dados acima usa o valor mínimo INT_MIN?
Porque é conveniente estabelecer uma árvore de perdedor durante o primeiro ajuste.
P2: Por que os pontos de dados abaixo de loserTree [2] às vezes são dados [0] e às vezes dados [n-1]?
Como a relação entre os nós folha e os nós internos é obtida por nós mesmos, ou seja,
t = (s + Len) / 2; de modo que quando ajustamos a árvore perdedora para passar o parâmetro s, ela especificará se você é dados [0] ou dados [n -1]; Em suma, como o relacionamento entre os nós folha e os nós internos é definido por nós mesmos, como os dados são conectados depende da fórmula de conexão. Se você não entende, você pode ver o código abaixo.
3 Implementação do código
int ls [K]; // ls [0] armazena o subscrito mínimo, 1-K-1 armazena os nós internos, ou seja, o segundo colocado a cada vez
int b [k + 1]; // ls [K] armazena Valor mínimo, 0-K-1 salvar dados
void CreateLoser() {
//1 初始化数据节点的最小值
b[m_file] = MIN;
//2 初始化内部节点记录的下标
for (int i = 0; i < m_file; i++) {
ls[i] = m_file;
}
//3 调整败者树
for (int i = m_file - 1; i >= 0; i--) {
Adjust(i);
}
}
//调整败者树 s一开始代表当前节点，实际是一直指向胜利者，即数据最小的值(与用于初始化的最小值MIN不一样)
void Adjust(int s) {
int tmp;
int t = (s + m_file) / (2); //叶子节点与内部节点建立关系，t代表当前节点s的父节点
while (t > 0) {
//t=0,即父节点是ls[0]节点时，证明该次排序调整结束，已经找到最小值了嘛
if (b[s] > b[ls[t]]) {
//新入树节点大于上一次的父节点，父节点记录新的失败者
tmp = s;
s = ls[t]; //s永远指向胜利者，即最小值
ls[t] = tmp; //父节点保存新的失败者
}
t = t / 2; //沿根节点上比较
}
ls[0] = s;
}