Análisis e implementación de código del árbol perdedor de 22 funciones
1 El proceso de construcción del árbol perdedor
2 Analice la figura anterior El
árbol perdedor está compuesto por nodos internos y nodos hoja.
1) Los nodos internos se refieren a excepto los nodos hoja y ls [0];
2) Los nodos hoja son nodos de datos;
si hay K datos, el nodo hoja es K y el nodo interno es K-1. Pero en el proceso de implementación del código, debe haber un valor mínimo y un lugar para almacenar el índice de valor mínimo, y el valor mínimo se almacena en el nodo hoja, el índice de valor mínimo se almacena en ls [0]. Por lo tanto, la longitud de la matriz de nodos de datos es K + 1; la longitud del nodo interno es K.
P1: ¿Por qué el nodo de datos anterior usa el valor mínimo INT_MIN?
Porque es conveniente establecer un árbol de perdedores durante el primer ajuste.
P2: ¿Por qué los puntos de datos debajo de loserTree [2] a veces son datos [0] y, a veces, datos [n-1]?
Porque la relación entre los nodos hoja y los nodos internos la conseguimos nosotros mismos, es decir,
t = (s + Len) / 2; de modo que cuando ajustamos el árbol perdedor para pasar el parámetro s, especificará si eres data [0] o data [n -1]; En resumen, dado que la relación entre los nodos hoja y los nodos internos la definimos nosotros mismos, la forma en que se conectan los datos depende de la fórmula de conexión. Si no lo entiende, puede ver el código a continuación.
3 Implementación del código
int ls [K]; // ls [0] almacena el subíndice mínimo, 1-K-1 almacena los nodos internos, es decir, el subcampeón cada vez que
int b [k + 1]; // ls [K] almacena Valor mínimo, 0-K-1 guardar datos
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;
}