ÁRBOL AVLDiego Márquez De La Hoz

Ingeniería de Sistemas

Descripción

"Un algoritmo para la organización de lainformación“.(Adelson-Velskii y Landis)

Están siempre equilibrados. Es decir, para todoslos nodos, la altura de la rama izquierda no difiereen más de una unidad de la altura de la ramaderecha o viceversa.

La complejidad de una búsqueda se mantienesiempre en orden de complejidad O(log n).

Para conseguir la propiedad de equilibrio, lainserción y el borrado de los nodos se ha derealizar de una forma especial. Si no se preservaesta propiedad, hay que realizar una serie derotaciones de los nodos.

Factor de equilibrio

Cada nodo, además de la información que se

pretende almacenar, debe tener los dos

punteros a los árboles derecho e

izquierdo, igual que los árboles binarios de

búsqueda (ABB), y además el dato que

controla el factor de equilibrio.

El factor de equilibrio es la diferencia entre las

alturas del árbol derecho y el izquierdo:

FE = altura subárbol derecho - altura subárbol

izquierdo

OPERACIONES

Rotación simple a la derecha

De un árbol de raíz (r) yde hijos izq. (i) yder.(d), se formara unnuevo árbol cuya raízsea la raíz del hijoizq., como hijo izq.colocamos el hijo izq.de i (i’) y como hijo der.construimos un nuevoárbol que tendrá comoraíz, la raíz del árbol(r), el hijo der. de i (d’)será el hijo izq. y el hijoder. será el hijoderecho del árbol (d).

Rotación simple a la

izquierda De un árbol de raíz (r) y

de hijos izq. (i) y der.(d), se formara unnuevo árbol cuya raízsea la raíz del hijoder., como hijo der.colocamos el hijo der.de d (d’) y como hijoizquierdo construimosun nuevo árbol quetendrá como raíz la raízdel árbol (r), el hijo izq.de d será el hijoderecho (i’) y el hijo izq.será el hijo izq. delárbol (i).

Inserción

Puede ser realizada insertando el valor dado en el

árbol como si fuera un árbol de búsqueda binario

desequilibrado y después retrocediendo hacia la

raíz, rotando sobre cualquier nodo que pueda

haberse desequilibrado durante la inserción.

Proceso de inserción:

1. buscar hasta encontrar la posición de inserción

2. insertar el nuevo nodo con factor de equilibrio

3. repasar el camino de búsqueda, verificando el

equilibrio de los nodos, y re-equilibrando si es

necesario

Extracción

Una extracción trae consigo una disminución

de la altura de la rama donde se extrajo y

tendrá como efecto un cambio en el factor de

equilibrio del nodo padre de la rama en

cuestión, pudiendo necesitarse una rotación.

Borrar A, y la nueva raíz será M.

Borrado A, la nueva raíz es M.

Aplicamos la rotación a la derecha.

El árbol resultante ha perdido altura.

CÓDIGO EN JAVA

Class AvlNode

/**

*

* @author Diego

*/

public class AVLNode {

public Comparable dato; // el dato del nodo

public AVLNode izquierdo; // hijo izquierdo

public AVLNode derecho; // hijo derecho

public int height; // altura

// Constructors

public AVLNode(Comparable dato) {

this(dato, null, null);

}

public AVLNode(Comparable dato, AVLNode izq, AVLNode der) {

this.dato = dato;

this.izquierdo = izq;

this.derecho = der;

height = 0; // altura predeterminada

}

}

Class AvlTree

public class AVLTree {

private AVLNode root;

public void insert(Comparable x) {

root = insertar(x, root);

}

/*

* x es una instancia de una clase que implementa Comparable

*/

private AVLNode insertar(Comparable x, AVLNode t) {

if (t == null) {

t = new AVLNode(x, null, null);

} else if (x.compareTo(t.dato) < 0) {

t.izquierdo = insertar(x, t.izquierdo);

if (height(t.izquierdo) - height(t.derecho) == 2) {

if (x.compareTo(t.izquierdo.dato) < 0) {

t = rotacionHijoIzquierdo(t); /* Caso 1 */

} else {

t = rotacionDobleHijoIzquierda(t); /* Caso 2 */

}

}

} else if (x.compareTo(t.dato) > 0) {

t.derecho = insertar(x, t.derecho);

if (height(t.derecho) - height(t.izquierdo) == 2) {

if (x.compareTo(t.derecho.dato) > 0) {

t = rotacionHijoDerecho(t); /* Caso 4 */

} else {

t = rotacionDobleHijoDerecho(t); /* Caso 3 */

}

}

private static int max(int izquierdaHeight, int derechaHeight) {

return izquierdaHeight > derechaHeight ? izquierdaHeight : derechaHeight;

}

private static AVLNode rotacionHijoIzquierdo(AVLNode t) {

AVLNode aux2 = t.izquierdo;

t.izquierdo = aux2.derecho;

aux2.derecho = t;

t.height = max(height(t.izquierdo), height(t.derecho)) + 1;

aux2.height = max(height(aux2.izquierdo), t.height) + 1;

return aux2;

}

private static AVLNode rotacionHijoDerecho(AVLNode t) {

AVLNode aux2 = t.derecho;

t.derecho = aux2.izquierdo;

aux2.izquierdo = t;

t.height = max(height(t.izquierdo), height(t.derecho)) + 1;

aux2.height = max(height(aux2.derecho), t.height) + 1;

return aux2;

}

private static AVLNode rotacionDobleHijoIzquierda(AVLNode aux) {

aux.izquierdo = rotacionHijoDerecho(aux.izquierdo);

return rotacionHijoIzquierdo(aux);

}

private static AVLNode rotacionDobleHijoDerecho(AVLNode aux) {

aux.derecho = rotacionHijoIzquierdo(aux.derecho);

return rotacionHijoDerecho(aux);

}

private static int height(AVLNode t) {

return t == null ? -1 : t.height;

}

/*

* Imprime el arbol con el recorrido InOrden

*/

public void imprimir() {

imprimir(root);

}

private void imprimir(AVLNode nodo) {

if (nodo != null) {

imprimir(nodo.derecho);

System.out.println("[" + nodo.dato + "]");

imprimir(nodo.izquierdo);

}

}

public void imprimirPorAltura() {

imprimirPorltura(root);

}

/*

* Imprime cada nodo linea por linea. Recorriendo el arbol desde

* el Nodo más a la derecha hasta el nodo más a la izquierda,

* y dejando una identacion de varios espacios en blanco segun su

* altura en el arbol

*/

private void imprimirPorltura(AVLNode nodo) {

if (nodo != null) {

imprimirPorltura(nodo.derecho);

System.out.println(replicate(" ", height(root) - height(nodo)) + "[" + nodo.dato + "]");

imprimirPorltura(nodo.izquierdo);

}

}

/*

* Metodo estatico auxiliar que dada una cadena a y un enterto cnt

* replica o concatena esa cadena a, cnt veces

*/

private static String replicate(String a, int cnt) {

String x = new String("");

for (int i = 0; i < cnt; i++) {

x = x + a;

}

return x;

}

/*

* Obtiene la altura del arbol AVL

*/

public int calcularAltura() {

return calcularAltura(root);

}

private int calcularAltura(AVLNode actual) {

if (actual == null) {

return -1;

} else {

return 1 + Math.max(calcularAltura(actual.izquierdo), calcularAltura(actual.derecho));

}

}

// Imprime el arbol por niveles. Comienza por la raiz.

public void imprimirPorNiveles() {

imprimirPorNiveles(root);

}

// Imprime el arbol por niveles.

private void imprimirPorNiveles(AVLNode nodo) {

// Mediante la altura calcula el total de nodos posibles del árbol

// Y crea una array cola con ese tamaño

int max = 0;

int nivel = calcularAltura();

for (; nivel >= 0; nivel--) {

max += Math.pow(2, nivel);

}

max++; // Suma 1 para no utilizar la posicion 0 del array

AVLNode cola[] = new AVLNode[max];

// Carga en la pos 1 el nodo raiz

cola[1] = nodo;

int x = 1;

// Carga los demas elementos del arbol,

// Carga null en izq y der si el nodo es null

// i aumenta de a 2 por q carga en izq y der los hijos

// x aumenta 1, que son los nodos raiz - padre

for (int i = 2; i < max; i += 2, x++) {

if (cola[x] == null) {

cola[i] = null;

cola[i + 1] = null;

} else {

cola[i] = cola[x].izquierdo;

cola[i + 1] = cola[x].derecho;

}

}

nivel = 0;

int cont = 0; // contador para cada nivel

int cantidad = 1; // cantidad de nodos por nivel

int ultimaPosicion = 1; // ultimaPosicion del nodo en la cola de cada nivel

// Cuando i es = a 2^nivel hay cambio de nivel

// 2 ̂0 = 1 que es el nodo raiz

for (int i = 1; i < max; i++) {

if (i == Math.pow(2, nivel)) {

// Nodo raiz tiene nivel 1, por eso (nivel + 1)

System.out.print("\n Nivel " + (nivel) + ": ");

nivel++;

}

if (cola[i] != null) {

System.out.print("[" + cola[i].dato + "]");

cont++;

}

if (ultimaPosicion == i && cantidad == Math.pow(2, --nivel)) {

if (cantidad == 1) {

System.out.print(" Cantidad de nodos: " + cont + " (raiz)");

} else {

System.out.print(" Cantidad de nodos: " + cont);

}

cont = 0;

cantidad *= 2;

ultimaPosicion += (int) Math.pow(2, ++nivel);

}

}

}

}

Class EjecutableAvlTree

/**

*

* @author Diego

*/

public class EjecutableAVLTree {

/**

* @param args the command line arguments

*/

public static void main(String[] args) {

// TODO code application logic here

AVLTree arbolAVL = new AVLTree();

Integer elemento1 = new Integer("1");

Integer elemento2 = new Integer("2");

Integer elemento3 = new Integer("3");

Integer elemento4 = new Integer("4");

Integer elemento5 = new Integer("5");

Integer elemento6 = new Integer("6");

Integer elemento7 = new Integer("7");

Integer elemento8 = new Integer("15");

Integer elemento9 = new Integer("14");

Integer elemento10 = new Integer("13");

arbolAVL.insert(elemento1);

arbolAVL.insert(elemento2);

arbolAVL.insert(elemento3);

arbolAVL.insert(elemento4);

arbolAVL.insert(elemento5);

arbolAVL.insert(elemento6);

arbolAVL.insert(elemento7);

arbolAVL.insert(elemento8);

arbolAVL.insert(elemento9);

arbolAVL.insert(elemento10);

arbolAVL.imprimirPorNiveles();

int altura = arbolAVL.calcularAltura() + 1;

System.out.println("\n");

System.out.println(altura + " altura del arbol");

System.out.println("\n");

arbolAVL.imprimirPorAltura();

}

}