Programación III sección: C

Nombres y apellidos: Ismar Leonel Cortez Sanchez

Carné: 0901-21-506 Fecha de entrega: 16/03/2023

Actividad 16 de marzo.

Equilibrio del árbol a mano.

Primero equilibro el árbol a mano siguiendo un procedimiento.

Siendo las rotaciones por utilizar las siguientes:

El código por utilizar sería el siguiente, el de rotación doble derecha:

void RDD(Arbol* raiz, Arbol nodo)
{
cout << "Se hizo una rotacion Doble derecha";
pNodo Padre = nodo->padre;
pNodo P = nodo;
pNodo Q = P->izquierdo;
pNodo R = Q->derecho;
pNodo B = R->izquierdo;
pNodo C = R->derecho;

if (Padre)
if (Padre->derecho == nodo) Padre->derecho = R;
else Padre->izquierdo = R;
else *raiz = R;

/* Reconstruir árbol: */
Q->derecho = B;
P->izquierdo = C;
R->izquierdo = Q;
R->derecho = P;

/* Reasignar padres: */
R->padre = Padre;
P->padre = Q->padre = R;
if (B) B->padre = Q;
if (C) C->padre = P;

/* Ajustar valores de FE: */

switch (R->FE) {
case -1: Q->FE = 0; P->FE = 1; break;
case 0: Q->FE = 0; P->FE = 0; break;
case 1: Q->FE = -1; P->FE = 0; break;
}
R->FE = 0;}
Esto lo comprobados en el programa con el siguiente ejemplo:

En donde si ingresamos “3,1,2” el programa en cuestión ordenara el árbol, y lo colocara como el

anterior, balanceado y en orden, siendo un AVL.
Ahora si vemos el recorrido de los árboles:

Podemos ver que ahora la raíz es el número 2, cumpliéndose así con el ejemplo, siendo el código
necesario para poder balancearlo manteniendo el orden también.
Tenemos el siguiente árbol:
En la primera parte del código, la función “updateHeight(z)” recibe un parámetro para actualizar la
altura, sin embargo, con la función “getBalance(z)”, se le asigna a “int balance” un valor entero
acerca de la altura del árbol (pudiendo ser un numero negativo o positivo, sabiendo que debe estar
entre -1, 0 y 1 el valor dado). Para la cual se realiza la primera validación, si el balance es mayor a 1
“if(balance>1)”, es porque sabemos que el lado derecho es mayor, siendo que esta más cargado el
árbol a la derecha y por ende no esta balanceado y se procede a la validación:
“if (height(z.right.right) > height(z.right.left))”, en donde, se verifica si la altura de la derecha es
mayor que la izquierda, si es así, se hace una rotación izquierda, o mejor dicho una rotación simple
izquierda “(RSI)” y en caso contrario, se rotara de igual manera, ya que Z accederá a la derecha y
por ende luego rotara con su correspondiente función.

En la otra parte del código de verifica que el valor del balance se menor de 1, siendo que si es menor
de “-1” es porque la parte izquierda del árbol esta sobre cargada. Para lo cual, se valida si la altura
izquierda es mayor que la derecha, se hace una rotación derecha “(RSD)”, y en caso de que no sea
mayor como tal, de igual manera Z accede a la izquierda y le asigna la rotación, siendo que de igual
manera se da.
Para el árbol dado en el ejercicio, tendríamos lo siguiente:

Sabiendo que la altura es “-3”, siendo más grande en la izquierda, aplicándose esta parte de código:

En donde se verifica que el balance es menor de 1, sin embargo, la izquierda no es más grande que
la derecha, aunque esta desbalanceado, se aplica el else.

En donde se accede al campo “left” y se le agrega el valor de la rotación, siendo que luego se termina
de rotar a la derecha de esta manera, aplicando una “(RSD)” rotación simple derecha.
Siendo que el árbol en cuestión quedara balanceado.