Arboles Fit 2011

Fundamentos de Informtica Terica Dr. Eric Jeltsch F.

_____________________________________________________________________________Escuela de Ingeniera en Computacin, Universidad de La Serena.

1

Estructuras dinmicas de datos Contenidos:

1. Arbol (Tree) 2. Arbol Bsqueda Binaria(ABB), Heap, 3. AVL, y otros.

Introduccin En esta seccin se presentan los rboles, como un caso particular del objeto Grafo. En general los rboles son uno de los tipo de dato abstracto ms adecuado para el tratamiento de grandes cantidades de informacin, las aplicaciones de los mismos son muy diversas, as por ejemplo, se usan para el almacenamiento y bsqueda de informacin ya que pueden establecerse diversas formas en las que el tiempo medio de las operaciones de bsqueda es del orden de log(n), lo que es bastante bueno comparado por ejemplo, con las listas enlazadas en la bsqueda de alguna informacin. Otros mbitos de aplicacin son en la implementacin del sistema de archivos en los sistemas operativos, manejo de archivos en las base de datos. En este segmento veremos una diversidad de estructuras de datos dinmicas y propiedades de los rboles Binario, ABB, rboles AVL, entre otros. Lo sustantivo en este segmento ser el reconocer las estructuras, manejar sus propiedades de equilibrio a travs de las rotaciones, su performance o rendimiento, implementacin(que las ver seguramente en la asignatura de Estructuras de Datos, o sino de todas maneras en Diseo y Anlisis de Algoritmos, junto con una serie de aplicaciones. Adems, como ya hemos visto, muchas aplicaciones requieren de un conjunto dinmico que soporte solamente las operaciones de Diccionario, a saber, Insert, Search, y Delete. Consideremos en este contexto el problema de cmo recuperar eficientemente el registro de alumnos. Dada una clave buscada K, que corresponde a un alumno en particular y una tabla T, que consiste de 5.000 alumno. Cmo organizar T, de manera que la bsqueda de la clave K sea eficiente como sea posible? Una forma: usar un registro implementado a travs de un array en orden numrico ascendente sobre las claves y usar posteriormente bsqueda binaria para localizar el registro. a) Bsqueda binaria toma aproximadamente (log2 (5001)-1) comp. ( 11.3), sobre el promedio, si

cada clave es igualmente probable a ser usada. b) Otra posibilidad es usar o dejar los registros en un AVL, de acuerdo al nmero del alumno. En

este caso, sobre el promedio, la bsqueda en un AVL es (log 25000 + 0.25) comp. ( 12.5 ).

Sin embargo, usando la tcnica hashing doble se puede afirmar que almacenando 5000 alumnos en una tabla T que tiene espacio para 6.000 alumnos reduce el n promedio de comparaciones necesarias para localizar a algn alumno, realizando efectivamente (2.15)-comp. De manera, que la tcnica del Hashing permite recuperar la informacin casi 4 veces ms rpido eficiente que las otras estructuras. Sin embargo, no todo es del tipo Diccionario lo que se puede hacer con la informacin. Arbol Un rbol es una estructura no lineal formada por un conjunto de nodos y un conjunto de ramas o arcos. De un punto de vista ms tcnico digamos que los rboles se basan en el concepto de nodo, que corresponde a cualquier tipo cuyos elementos son registros formados por un campo de datos y un nmero dado de punteros, tal como se vieron en las listas enlazadas.



2

Mundo Real Mundo Virtual Mundo de la Fantasa

Ahora, si los nodos estn rotulados con el fin de almacenar un tipo de informacin, tenemos una gran variedad de rboles. En general, digamos que en un rbol existe un nodo especial denominado raz. As mismo, un nodo del que sale alguna rama, recibe el nombre de nodo de bifurcacin o nodo rama y un nodo que no tiene ramas recibe el nombre de nodo terminal o nodo hoja, tal como lo muestra la siguiente figura.

De un modo ms formal, diremos que un rbol es un conjunto finito de uno o ms nodos tales que:

a) Existe un nodo especial llamado raz del rbol, y b) los nodos restantes estn agrupados en n > 0 conjuntos disjuntos A1, .., An donde cada uno de los cuales es a su vez un rbol que recibe el nombre de subrbol. Evidentemente, la definicin dada es recursiva; es decir, hemos definido un rbol como un conjunto de rboles. De la definicin se desprende, que cada nodo de un rbol es la raz de algn subrbol contenido en la totalidad del mismo. El nmero de ramas de un nodo recibe el nombre de grado del nodo. El nivel de un nodo respecto al nodo raz se define diciendo que la raz tiene nivel 0 y cualquier otro nodo tiene un nivel igual a la distancia de ese nodo al nodo raz. El mximo de los niveles se denomina profundidad o altura del rbol. Es til limitar los rboles en el sentido de que cada nodo sea a lo sumo de grado 2. De esta forma cabe distinguir entre subrbol izquierdo y subrbol derecho de un nodo. Los rboles as formados, se denominan rboles binarios. Un rbol binario es un conjunto finito de nodos que consta de un nodo raz que tiene dos subrboles binarios denominados subrbol izquierdo y subrbol derecho. Para motivar su utilidad digamos que los diagramas de Venn y su anidacin de parntesis (A (B (D ( I ), E, F (J, K )), C (G, H ( L )))), puede ser representada a travs de rbol.



3

Una de las aplicaciones tpicas de los rboles binario es la representacin de expresiones algebraicas, debido a que los operadores que intervienen son operadores binarios. La figura siguiente nos muestra un rbol que corresponde a la expresin aritmtica: (a+b*c)/(d-e/f)

Una combinacin de los dos anteriores surge al considerar (A1 ((A 2 ) ( A3 ))) (((A4 ) (A 5 ))A6 ), que corresponde a la forma ptima de parentizar un producto de matrices de algn orden el que se puede representar por el rbol binario siguiente

El rbol binario es una estructura de datos muy til cuando el tamao de la estructura no se conoce, y se necesita acceder a sus elementos ordenadamente, la velocidad de bsqueda es importante o el orden en el que se insertan los elementos es casi aleatorio. En definitiva, un rbol binario es una coleccin de objetos (nodos del rbol) cada uno de los cuales contiene datos o una referencia a los datos, una referencia a su subrbol izquierdo y una referencia a su subrbol derecho. Segn lo expuesto, la estructura de datos representativa de un nodo puede ser de la forma siguiente:

Si el nmero de nodos en un rbol de orden t es N, entonces un rbol completo de altura h contiene:

(1) N t tt

ih

i

h

= =

= 1

1

11

En particular, un rbol binario (t = 2) contiene N h= 2 1 nodos. Esto nos dice que para un rbol binario de altura h = 3, se tienen 7 nodos. Tal como se ve en la siguiente figura, estamos frente a un rbol binario completo y el otro que no lo es



4

En general, un rbol del tipo como la figura tambin es considerado completo, pero no full. Mientras que el de enfrente No es completo. Ya que, el sentido de completitud, es considerado que se van completando por niveles de arriba hacia abajo y de izquierda a derecha.

Clasificacin de los rboles A causa del gran significado que poseen los rboles es que se hace necesaria una clasificacin, tanto en la forma, como los datos que son almacenados en los rboles, as como en la forma de buscar un tipo de informacin, y de recorrer los nodos. En general, los datos o informacin se encuentra en los nodos, de aqu que consideremos en forma particular los rboles binarios y la forma de cmo disponer su informacin, generando un tipo de rbol llamado rbol de bsqueda binaria. ABB(rboles de bsqueda binaria) Las claves o datos son dispuestas de la siguiente manera: los datos menores a la izquierda y los mayores a la derecha. En la siguiente figura se puede constatar fcilmente la posicin en la cual se encuentra algn dato en particular.

40

30 50

4439 6020

6211 24 37 40 41 45 65 Arboles de Decisin(o rbol de bsqueda o de comparaciones) Este tipo de rboles es aplicado a los algoritmos el cual se obtiene al trazar de principio a fin la accin del algoritmo, representando cada comparacin como un vrtice del rbol. En los rboles binarios se da la situacin de dos comparaciones, las que se pueden codificar por: - 0 : Decisin para el hijo izquierdo - 1 : Decisin para el hijo derecho En el ejemplo, se muestra el rbol de comparaciones para la bsqueda secuencial, en donde debemos resaltar los cajones como nodos externos o especiales y los nodos en donde se encuentra la informacin, generndose as un nuevo tipo de rbol, llamado rbol extendido.



5

En este sentido, el rbol de comparaciones cambia radicalmente su rotulacin si incorporamos la comparacin , o =, tal como se ve en la siguiente figura, cuando n =10, en la cual se combinan dos comparaciones a fin de obtener una comparacin de tres vas para cada paso, as el rbol se ve ms compacto, en comparacin con el rbol que considera las comparaciones a la izquierda y > a la derecha.

Supongamos que deseamos ordenar tres datos A, B y C. La siguiente figura muestra un rbol de decisin posible para resolver este problema. Los nodos internos del rbol representan comparaciones y los nodos externos representan salidas emitidas por el programa.

Todo rbol de decisin con H hojas tiene al menos altura log2 H, y la altura del rbol de decisin es igual al nmero de comparaciones que se efectan en el peor caso. En un rbol de decisin para ordenar n datos se tiene que H=n!, y por lo tanto se tiene que todo algoritmo que ordene n datos mediante comparaciones entre llaves debe hacer al menos log2 n! comparaciones en el peor caso. Usando la aproximacin de Stirling, se puede demostrar que log2 n! = n log2 n + O(n), por lo cual la cota inferior es de O(n log n). Basado en la forma de rotular los nodos, podramos clasificar los rboles en rboles orientados a los nodos y rboles orientados a las hojas, para distinguirlos digamos que los primeros son rboles en



6

donde los datos se encuentran en los nodos del rbol, mientras que los otros son rboles en donde los datos se encuentran solamente en las hojas. Convengamos que, tal como la figura anterior si el rbol es ampliado con nodos especiales, de manera que todos los subrboles estn completos, es decir todos los apuntadores sin nodos descendientes apuntan a un nodo especial, se habla de un rbol extendido. En este contexto, se define la longitud de camino X como el nmero de arcos que deben ser recorridos para llegar desde la raz al nodo X. por definicin la raz tiene longitud de camino 1, sus descendientes directos 2 Por otra parte, la longitud de camino interno de un rbol, es la suma de todas las longitudes de trayectoria de sus nodos, y se calcula por medio de la siguiente frmula.

donde i = nivel del rbol, h = altura del rbol, ni = nmero de nodos en el nivel i. Por otra parte, la media de la longitud de camino, se calcula por la formula LCI /N, donde N es el nmero de nodos. En este grafo el LCI = 1*1 + 2*2 + 5*3 + 4*4 = 36.

Otra forma de clasificacin es considerar rboles optimal estticos u optimal dinmicos, los primeros significa que el rbol debe ser construido nuevamente, mientras que el otro se construye durante el ingreso o al agregar los datos. El objetivo final en ambos casos es lograr una razonable estructura de almacenamiento, aunque esta situacin en general globalmente no se pueda lograr, pero s localmente. En ambos casos, se evitan rboles degenerados, que son los rboles que degeneran en listas lineales o ramas, de ah que surjan las rotaciones como una forma de evitar este tipo de situaciones. Los rboles sirven tambin para representar una jerarqua, tal como lo muestra el siguiente ejemplo, respecto de la representacin de expresiones aritmticas. Por ejemplo, para la expresin ( / ( )A B C) D E F+ se puede representar por el siguiente rbol:

*

+ -

D/ *A

EB C F Relacin de Orden y Representacin En cada nodo, se da una situacin de orientacin y jerarquerizacin en los rboles binarios: Toda clave al lado derecho(izq) de los subarboles son mayores(menores) a la clave del nodo. Con ayuda

=

=h

ii inLCI

1*



7

de esta relacin de orden se generan rbol que sirven para buscar, borrar o hallar algn elemento en particular.

La bsqueda de un elemento se realiza desde la raz hasta el nodo en donde se encuentra la clave, en caso de existir, en caso contrario no existe el dato. 1. Las dos claves son iguales, la que se busca y la que tiene el nodo: el elemento es encontrado. 2. La clave buscada es pequea: el elemento buscado se encuentra solamente en los subarboles izquierdo. 3. La clave buscada es mayor: el elemento buscado se encuentra solamente en los subarboles derecho. Este proceso se realiza hasta que la clave es encontrada. Notar que la estructura y crecimiento de los rboles binarios son a travs de una relacin de orden, por tal motivo se generan varios rboles con rotulaciones distintas. Por ejemplo, se dan las 3 claves 1, 2 y 3, tan solo con estas podemos generar distintos rboles binarios respetuosos del orden antes descrito, por ejemplo

existiendo 6 distintas formas de rotularlos y por ende 6 rboles binarios distintos. En general, se demuestra que n-elementos generan n! formas.



8

Operaciones Veamos como generar un rbol de bsqueda binaria a partir del rbol vaco, al cual se le agregan los datos (12, 7, 15, 5, 13).

Insercin en un ABB 1) comparar la clave a insertar con la raz del rbol. Si es mayor, debe avanzar hacia el subarbol derecho. Si es menor, debe avanzar hacia el subarbol izquierdo. Repetir sucesivamente 1), hasta que se cumpla alguna de las siguientes condiciones: a) el subarbol derecho es vaco, o el subarbol izquierdo es vaco; en cuyo caso se procede a insertar el elemento en el lugar que le corresponda. b) la clave que se quiere insertar es igual a la raz del rbol; en cuyo caso no se realiza la insercin. Por ejemplo, insertar 120, 87 y 130, en ese orden a partir del rbol vaco.

Eliminacin en un ABB Se refiere a eliminar un Nodo con una determinada clave, suponiendo que el elemento ha sido encontrado. Existen varias situaciones, entre ellas estn: a) Si el elemento a borrar es terminal u hoja, simplemente se elimina.

b) Si el elemento a borrar tiene un solo descendiente, entonces tiene que sustituirse por ese descendiente.



9

c) Si el elemento a borrar tiene los 2 descendientes, entonces se tiene que sustituir por el nodo que se encuentra ms a la izquierda en el subrbol derecho o por el nodo que se encuentra ms a la derecha en el subrbol izquierdo.

Ejemplo: Veamos como va quedando el ABB, luego de realizar una serie de eliminaciones.

Para cuando se eliminen los valores 2 y 6. Se tiene (caso a)



10

a) 13(caso b)

d) 15 (caso b)

e) 5 (caso a)

f) 12 (caso c)

Dado el rbol bsqueda binaria. Se desea eliminar el 12, como queda el ABB.?



11

Recorrido y orden en Arboles Binario El principio de recorrer un rbol binario, determina un orden sobre el conjunto de nodos. Existen 3 posibilidades o principios de como recorrer un rbol binario, ellos son la lectura en Inorden, Preorden y Posorden. Inorden Orden IRD (1) Recorrer el subrbol izquierdo en INORDEN (2) Visitar la raz (3) Recorrer el subrbol derecho en INORDEN Orden DRI (1) Recorrer el subrbol derecho en INORDEN (2) Visitar la raz (3) Recorrer los subrbol derecho en INORDEN Los orden IRD y DRI son uno inverso del otro. El orden IRD, se llama orden simtrico Preorden Orden RID (1) Visitar la raz (2) Recorrer el subrbol izquierdo en PREORDEN (3) Recorrer el subrbol derecho en PREORDEN Orden RDI (1) Visitar la raz (2) Recorrer el subrbol derecho en PREORDEN (3) Recorrer el subrbol izquierdo en PREORDEN En general se visita la raz antes de los dos subrboles. Posorden Orden IDR (1) Recorrer el subrbol izquierdo en POSTORDEN (2) Recorrer el subrbol derecho en POSTORDEN



12

(3) Visitar la raz Primero se visitan los subrboles y luego la raz. Orden DIR (1) Recorrer el subrbol derecho en POSTORDEN (2) Recorrer el subrbol izquierdo en POSTORDEN (3) Visitar la raz Primero se visitan los subrboles y luego la raz. Por ejemplo, se dan una serie de rboles binarios, y la idea es describir su recorrido en las formas antes definidas. 1.-

2.

Este ejemplo nos muestra una estructura de rbol (representacin de una estructura jerarquica de una expresin aritmtica). Esta representacin arbrea es en particular muy til para la traduccin de una expresin en lenguaje de mquina. Desde la estructura anterios se pueden representar fcilmente las distintas formas de una expresin aritmtica. Entregando de esta manera el recorrido en "Posorden" como la notacin Postfija, y en "Preorden" la notacin Prefija". 3.



13

4.

Aplicaciones de los recorridos Con ayuda de los recorridos antes descritos se pueden determinar algunas otras operaciones sobre los rboles. Por ejemplo, determinar el nmero de hojas en el rbol, entregar la altura del rbol, copiar el rbol, borrar el rbol, descripcin grfica de un rbol de bsqueda binaria. En un rbol de bsqueda binario se puede dar la siguiente situacin, la que se interpreta como un rbol de bsqueda binario que degenero en una lista lineal, derivando en que la bsqueda de algn elemento en particular resulta tan costoso como buscarlo en forma exhaustiva, de aqu que es importante evitar que se genere una situacin de este tipo.

Para ello, estn los rboles perfectamente balanceados que evitan que se de una situacin como la descrita a continuacin, de manera de obtener una forma de balanceo que en definitiva facilita la bsqueda de algn elemento, pues no se encuentra a una profundidad tan alejado de la raz. Se verifica que el rbol de la derecha es rbol AVL, que luego lo veremos en detalle.

A continuacin se muestra un simple algoritmo que genera un rbol con las condiciones de balanceo. (1) ordenar las claves en una sucesin ordenada en forma creciente (2) es conocido el nmero de Objetos (claves) que se deben tener.



14

Se consideran dos tipos de recorrido: recorrido en profundidad y recorrido en anchura o a nivel. Puesto que los rboles no son secuenciales como las listas, hay que buscar estrategias alternativas para visitar todos los nodos. Dada la siguiente figura:

Figura 1

- Recorridos en profundidad:

Recorrido en preorden: consiste en visitar el nodo actual (visitar puede ser simplemente mostrar la clave del nodo por pantalla), y despus visitar el subrbol izquierdo y una vez visitado, visitar el subrbol derecho. Es un proceso recursivo por naturaleza. Si se hace el recorrido en preorden del rbol de la figura 1 las visitas seran en el orden siguiente: a,b,d,c,e,f.

Recorrido en inorden u orden central: se visita el subrbol izquierdo, el nodo actual, y despus se visita el subrbol derecho. En el ejemplo de la figura 1 las visitas seran en este orden: b,d,a,e,c,f.

private void printTree(Nodo_ABB b) { if(b != null) { printTree(b.izq); System.out.print(b.dat); System.out.print(' '); printTree( b.der ); } } Recorrido en postorden: se visitan primero el subrbol izquierdo, despus el subrbol derecho, y por ltimo el nodo actual. En el ejemplo de la figura 1 el recorrido quedara as: d,b,e,f,c,a.

La ventaja del recorrido en postorden es que permite borrar el rbol de forma consistente. Es decir, si visitar se traduce por borrar el nodo actual, al ejecutar este recorrido se borrar el rbol o subrbol que se pasa como parmetro. La razn para hacer esto es que no se debe borrar un nodo y despus sus subrboles, porque al borrarlo se pueden perder los enlaces, y aunque no se perdieran se rompe con la regla de manipular una estructura de datos inexistente. Una alternativa es utilizar una variable auxiliar, pero es innecesario aplicando este recorrido.

- Recorrido en amplitud:



15

Consiste en ir visitando el rbol por niveles. Primero se visitan los nodos de nivel 1 (como mucho hay uno, la raz), despus los nodos de nivel 2, as hasta que ya no queden ms. Si se hace el recorrido en amplitud del rbol de la figura una visitara los nodos en este orden: a,b,c,d,e,f.

Construccin de un rbol binario

Hasta el momento se ha visto la declaracin y recorrido de un rbol binario. Sin embargo no se ha estudiado ningn mtodo para crearlos. A continuacin se estudia un mtodo para crear un rbol binario que no tenga claves repetidas partiendo de su recorrido en preorden e inorden, almacenados en sendos arrays.

Antes de explicarlo se recomienda al lector que lo intente hacer por su cuenta, es sencillo cuando uno es capaz de construir el rbol viendo sus recorridos pero sin haber visto el rbol terminado.

Partiendo de los recorridos preorden e inorden del rbol de la figura 1 puede determinarse que la raz es el primer elemento del recorrido en preorden. Ese elemento se busca en el array inorden. Los elementos en el array inorden entre izq y la raz forman el subrbol izquierdo. Asimismo los elementos entre der y la raz forman el subrbol derecho. Por tanto se tiene este rbol:

A continuacin comienza un proceso recursivo. Se procede a crear el subrbol izquierdo, cuyo tamao est limitado por los ndices izq y der. La siguiente posicin en el recorrido en preorden es la raz de este subrbol. Queda esto:

El subrbol b tiene un subrbol derecho, que no tiene ningn descendiente, tal y como indican los ndices izq y der. Se ha obtenido el subrbol izquierdo completo de la raz a, puesto que b no tiene subrbol izquierdo:



16

Despus seguir construyndose el subrbol derecho a partir de la raz a.

Aplicacin:

Se tiene un archivo de texto ASCII. Para este propsito puede servir cualquier libro electrnico de la librera Gutenberg o Cervantes, que suelen tener varios cientos de miles de palabras. El objetivo es clasificar todas las palabras, es decir, determinar que palabras aparecen, y cuantas veces aparece cada una. Palabras como 'nio'-'nia', 'vengo'-'vienes' etc, se consideran diferentes para simplificar el problema. Se pide, escribir un programa, que recibiendo como entrada un texto, realice la clasificacin descrita anteriormente.

Ntese que el empleo de una lista enlazada ordenada no es una buena solucin. Si se obtienen hasta 20.000 palabras diferentes, por decir un nmero, localizar una palabra cualquiera puede ser, y en general lo ser, muy costoso en tiempo. Se puede hacer una implementacin por pura curiosidad para evaluar el tiempo de ejecucin, pero no merece la pena.

La solucin pasa por emplear un rbol binario de bsqueda para insertar las claves. El valor de log(20.000) es aproximadamente de 14. Eso quiere decir que localizar una palabra entre 20.000 llevara en el peor caso unos 14 accesos. El contraste con el empleo de una lista es simplemente abismal. Por supuesto, como se ha comentado anteriormente el rbol no va a estar perfectamente equilibrado, pero nadie escribe novelas manteniendo el orden lexicogrfico (como un diccionario) entre las palabras, asi que no se obtendr nunca un rbol muy degenerado. Lo que est claro es que cualquier evolucin del rbol siempre ser mejor que el empleo de una lista.

Implementacin en Java

Por ltimo, veamos un ejemplo o propuesta de implementacin de los rboles ABB. Se muestra una implementacin (No genrica, es decir no usa Generics), pero si usa la interface Comparable y otras que vimos en programacin orientada a objetos. La propuesta se muestra en dos archivos, uno de ellos es Arbol_ABB.java y el otro Arbol_ABBTest.java. class Nodo_ABB { // Instancia (variables) protected Nodo_ABB izq; // sub arbol izq protected Nodo_ABB der; // sub arbol derecho public Comparable dat; // datos de los nodos // Constructor public Nodo_ABB(Comparable datElement)



17

{ this(datElement, null, null ); } public Nodo_ABB(Comparable datElement, Nodo_ABB i, Nodo_ABB d) { dat = datElement; izq = i; der = d; } public Nodo_ABB getIzq() { return izq; } public Nodo_ABB getDer() { return der; } } public class Arbol_ABB { /* la raz del rbol */ private Nodo_ABB root; /* * Constructor. */ public Arbol_ABB() { root = null; } /* * agregar un elemento en el ABB * los valores duplicados son ignorados */ public void insert( Comparable x ) { root = insert(x, root); } /* * eliminar de un ABB. En caso que no este, no pasa nada */ public void remove( Comparable x ) { root = remove(x, root); } /* * hallar el menor elemento del ABB */ public Comparable findMin() { return elementAt(findMin(root)); } /* * hallar el ms grande elemento en el ABB */ public Comparable findMax() { return elementAt(findMax(root)); } /* * hallar un elemento (dato) en el ABB */



18

public Comparable find(Comparable x) { return elementAt(find(x, root)); } /* * Hacer el ABB vaco */ public void makeEmpty() { root = null; } /* * Test, para saber si el ABB esta vacio */ public boolean isEmpty() { return root == null; } /* * salida de los elementos en orden */ public void printTree() { if( isEmpty( ) ) System.out.println( "ABB esta vacio" ); else printTree( root ); } /* * salida de los elementos, pero deben interpretarse (90 Grad rotados) */ public void salidaABB() { if( isEmpty() ) System.out.println( "ABB vacio" ); else salidaABB( root,0 ); } private Comparable elementAt( Nodo_ABB b ) { return b == null ? null : b.dat; } //insertar private Nodo_ABB insert(Comparable x, Nodo_ABB b) { if( b == null ) b = new Nodo_ABB( x, null, null ); else if( x.compareTo( b.dat ) < 0 ) b.izq = insert( x, b.izq ); else if( x.compareTo( b.dat ) > 0 ) b.der = insert( x, b.der ); else ; // Duplicado, no hace nada return b; } //eliminar private Nodo_ABB remove(Comparable x, Nodo_ABB b) { if( b == null ) return b; // no encontrado, no hace nada. if( x.compareTo(b.dat) < 0 ) b.izq = remove(x, b.izq ); else if( x.compareTo(b.dat) > 0 )



19

b.der = remove( x, b.der ); else if( b.izq != null && b.der != null ) // dos hijos { b.dat = findMin(b.der).dat; b.der = remove(b.dat, b.der); } else b = ( b.izq != null ) ? b.izq : b.der; return b; } //hallar el min private Nodo_ABB findMin(Nodo_ABB b) { if (b == null) return null; else if( b.izq == null) return b; return findMin(b.izq ); } //hallar el max private Nodo_ABB findMax( Nodo_ABB b) { if( b != null ) while( b.der != null ) b = b.der; return b; } //buscar un elemento private Nodo_ABB find(Comparable x, Nodo_ABB b) { if(b == null) return null; if( x.compareTo(b.dat ) < 0) return find(x, b.izq); else if( x.compareTo(b.dat) > 0) return find(x, b.der); else return b; // hallado! } //imprimir de una forma .. inorden private void printTree(Nodo_ABB b) { if(b != null) { printTree(b.izq); System.out.print(b.dat); System.out.print(' '); printTree( b.der ); } } /* * salida, pero el arbol esta rotado en 90 Grad.(puede mejorarse) */ private void salidaABB(Nodo_ABB b, int paso) { if (b != null) { salidaABB(b.izq, paso + 1); for (int i = 0; i < paso; i++) { System.out.print(' '); }



20

System.out.println(b.dat); salidaABB(b.der, paso + 1); } } } public class Arbol_ABB_Test { // Test o pruebas public static void main( String [] args ) { // Test Nr. 1 Arbol_ABB b = new Arbol_ABB(); final int NUMERO = 4000; final int ESPACIO = 37; System.out.println( "Probando...."); for( int i = ESPACIO; i != 0; i = (i + ESPACIO) % NUMERO) b.insert( new Integer( i ) ); for(int i = 1; i < NUMERO; i+= 2 ) b.remove( new Integer( i ) ); if (NUMERO < 40) b.printTree( ); if( ((Integer)(b.findMin( ))).intValue( ) != 2 || ((Integer)(b.findMax( ))).intValue( ) != NUMERO - 2 ) System.out.println( "fallas en FindMin o FindMax !" ); for( int i = 2; i < NUMERO; i+=2 ) if( ((Integer)(b.find( new Integer( i ) ))).intValue( ) != i ) System.out.println( "hallar fallas!" ); for( int i = 1; i < NUMERO; i+=2 ) { if( b.find( new Integer( i ) ) != null ) System.out.println( "encontrar error!" ); } // Test Nr.2 Arbol_ABB b1 = new Arbol_ABB(); for (int i = 0; i < 10; i++) { // genera n entre 0 y 100 Integer r = new Integer((int)(Math.random()*100)); b1.insert(r); } System.out.println("recorrido en Inorden"); b1.printTree(); System.out.println(); System.out.println("representacion del arbol, rotar en 90 Grados"); b1.salidaABB(); System.out.print("el menor valor: "); System.out.print(((Integer)(b1.findMin())).intValue()); System.out.println(); System.out.print("el mayor valor: "); System.out.print(((Integer)(b1.findMax())).intValue()); System.out.println(); for (int i = 0; i < 10; i++) { // genera n entre 0 y 100 Integer r = new Integer((int)(Math.random()*100)); if ( b1.find(r) != null ) { b1.remove( r ); } // else System.out.println(r.intValue() + " no encontrado.");



21

} b1.salidaABB(); // Test Nr. 3 Arbol_ABB b2 = new Arbol_ABB(); for (int i = 0; i < 20; i++) { String s = "n random " + (int)(Math.random() * 100); b2.insert(s); } b2.printTree(); // aparecen ordenados } }

Arboles AVL Introduccin: Una de las primeras estructuras de datos de rboles de bsqueda equilibrados que consideraremos son los rboles AVL ( que llevan el nombre de sus autores Adelson-Velskii-Landis), existen otros tipos de estructuras similares, tales como los rboles Red-Black y otros. En este informe se presenta la definicin de los rboles AVL, con ejemplos. Se hace una estimacin del nmero de nodos en el peor rbol AVL de altura h. Se revisa, en particular, el mtodo de Insertar, con ejemplos. Adems se muestra la implementacin en Java de cada uno de los componentes, tales como Nodo, Arbol AVL y las Rotaciones, como el medio para lograr la implementacin de Insercin en los rboles AVL. Finalmente, se hace una simulacin de la implementacin y se interpreta la salida, junto con mencionar algunas mejoras, u otras especificaciones que se le podran realizar, como por ejemplo considerar que se ingresan string y no enteros, que son los datos en que se basa la presente implementacin. Lo substancial de este informe se centra en poder superar el problema generado por la insercin en los ABB que podan degenerar en una lista proporcional a los datos ingresados y por otra reforzar los conceptos adquiridos en Estructuras de Datos. Definicin: Un rbol AVL es un rbol binario de bsqueda en el que las alturas de los subarboles izquierdos y derecho de cualquier nodo difieren a lo sumo en 1. Esta restriccin impuesta sobre la altura de los subarboles de un rbol AVL se le conoce como propiedad de los rboles AVL, y debe ser cumplida por todos y cada uno de los nodos del rbol.



22

Ejemplo: Los tres rboles que se muestran son del tipo AVL, mientras que los de enfrente no lo son.

Ejemplo: Basado en que los rboles AVL son rboles binarios es que a partir de un rbol vaco se han insertado los datos originando el rbol de la Fig. 1, el cual deja de tener la propiedad AVL. Pues, aunque los nodos 2, 4, 10, la posean considerando sus respectivos sub-arboles, notamos que en este caso la raz, es decir el nodo 8 no posee la propiedad de los rboles AVL pues la altura del subrbol izquierdo no difiere en a lo sumo 1 con el subrbol derecho, (en particular el subrbol izquierdo tiene altura 3, mientras que el subrbol derecho tiene altura 1. ( De all la marca que se considera como 2 bajo el nodo 8 y 1 bajo el nodo 4.

Los valores 2 y 1 se conocen como "Balance" de los nodos 8 y 4 respectivamente. H registra los valores de las alturas de los subrboles, los que deben ser -1 (balance_izq), 0 (balanceado) y +1 (balance_der). En este otro caso, todos los nodos satisfacen la condicin de balance, de manera que es un rbol AVL, como muestra Fig. 2

Sea T(h) cualquier rbol AVL que contenga N(h) nodos, con h>=2. Como T(h) es un rbol AVL, y supongamos que tenga el menor nmero de nodos, entonces uno de los subrboles de la raz debe tener altura h-1 y el otro deber tener altura h-2, de manera que el nmero de nodos de un rbol AVL en el caso peor de altura h viene dado por: (Ver (2), para mayor informacin)



23

N(h) = 1 + N(h-1) + N(h-2). Si suponemos que N(h) = 0 cuando h



24

Ya al insertar la clave 1 el rbol pierde la propiedad de AVL.. De aqu el aplicar una doble rotacin.

Arbol obtenido luego de insertar las claves 3, 5 y 7.

La propiedad de AVL se pierde si H = +2 resp. -2. Esto se remedia mediante rotaciones. Rotaciones a) Los rboles de Fig. 7 contienen los mismos elementos y son ambos rboles de bsqueda binaria. Primero, en ambos casos k1 < k2, segundo, todos los elementos en los subrboles X son menores que k1 en ambos rboles, tercero, todos los elementos en el subrbol Z son mayores que k2. Finalmente todos los elementos en el subrbol Y estn entre k1 y k2. La conversin de uno de ellos al otro se conoce como Rotacin simple, que significa en lo substancial cambiar la estructura del rbol. La figura 7 muestra las variantes simtricas y la doble rotacin.

Fig. 7 Representacin en Java Un rbol AVL se representa de la misma manera que un rbol binario de bsqueda, esto es con nodos que contienen punteros a su padre y a sus hijos izquierdo y derecho, sin embargo, un nodo ahora debe almacenar un campo adicional que indica la altura o balance del nodo. // Descripcin de un nodo para un rbol AVL class Nodo_Avl { // Instancias



25

protected Nodo_Avl izq; // hijo Izquierdo protected Nodo_Avl der; // hijo derecho protected int altura; // altura public Comparable datos; // elementos // Constructores public Nodo_Avl(Comparable datElem) { this(datElem, null, null ); } public Nodo_Avl( Comparable datElem, Nodo_Avl ib, Nodo_Avl db ) { datos = datElem; izq = ib; der = db; balance = 0; } } /* Este mtodo puede ser llamado solamente si k2 tiene un hijo izquierdo, realizando una rotacin entre el nodo k2, tal como lo muestra la figura 7. Adems, actualiza la altura, asignando la nueva raz a k2. */ private static Nodo_Avl RotacionSimpleIzq(Nodo_Avl k2) { Nodo_Avl k1 = k2.izq; k2.izq = k1.der; k1.der = k2; k2.altura = max( altura( k2.izq ), altura( k2.der ) ) + 1; k1.altura = max( altura( k1.izq ), k2.altura ) + 1; return k1; } b) Existen situaciones en donde el desbalanceo es generado por un nodo que es insertado en el rbol que est contenido en el subrbol de el medio( es decir Y) y que al mismo tiempo como los otros arboles tienen idntica altura. El caso es fcil de chequear y la solucin es llamada Rotacin Doble, la cual es muy similar a la rotacin simple salvo que ahora se ven involucrados 4 subrboles en vez de 3.

Fig.8: Rotacin Izq-Der, Rotacin Doble y en forma similar Rotacin Der-Izq, Rotacin Doble. /* Rotacin Doble, basada en Fig. 8: Este mtodo solo puede ser usado si k3 tiene hijo izquierdo y los hijos de k3 tienen hijo derecho. Esta rotacin se conoce como rotacin izq-der. Actualiza la altura, y su raz. */ private static Nodo_Avl DobleRotacionIzq_Der(Nodo_Avl k3) { /* Rotacin entre k1 y k2*/ k3.izq = RotationSimpleIzq( k3.izq); return RotationSimpleDer( k3 ); }



26

Ejemplo:

Rot.der-izq En este ltimo rbol se inserta la clave 13, quedando

Rot.der-izq Ud. podr verificar que cualquier desbalanceo causado por una insercin en un rbol AVL puede ser realizada por una Rotacin Doble o Simple, (Ver (1)). Ahora, respecto a la eficiencia de esta TDA mencionemos que almacenar la informacin de la altura, que en este caso son suficientes con +1, 0 y 1, es de gran utilidad /* Mtodo para calcular la altura de un nodo en un rbol AVL. */ private static int altura( Nodo_Avl b) { return b == null ? -1 : b.altura; } Entonces recordemos que para Insertar un nodo con la clave x en un rbol AVL, el valor x se inserta recursivamente en el subarbol correspondiente, tal como en los rboles de bsqueda binario. En el caso que la altura del subrbol no cambie, la insercin concluye. En caso contrario es necesario utilizar segn sea el caso, Rotacin Simple o Rotacin Doble. Implementacin de los rboles AVL //En archivo Arbol_AvlTest.java public class Arbol_AvlTest { // Programa Test public static void main(String [] args)



27

{ Arbol_Avl b1 = new Arbol_Avl(); Arbol_Avl b2 = new Arbol_Avl(); for (int i = 0; i < 7; i++) // { Integer r = new Integer(i); b1.insertar(r); } System.out.println("Arbol girado en 90 grados"); b1.salidaArbolBinario(); for (int i = 0; i < 10; i++) { // Genera un nmero entre 0 y 100 Integer r = new Integer((int)(Math.random()*100)); b2.insertar(r); } System.out.println("Arbol girado en 90 grados"); b2.salidaArbolBinario(); System.out.println("Travesia en Inorden(Izq-Raiz-Der)"); b2.printArbol(); } } //En archivo Arbol_Avl.java /* * Comparaciones se basan en el mtodo compareTo.(REPASAR lo visto en POO) */ public class Arbol_Avl { /* Raiz del Arbol */ private Nodo_Avl raiz; /* * Constructor por defecto */ public Arbol_Avl( ) { raiz = null; } /* * Insertar: Duplicados son ignorados. * x es el dato a ser insertado. */ public void insertar(Comparable x ) { raiz = insertar( x, raiz ); } /* * Eliminar un nodo del Arbol. Caso que x no este, * nada ocurre. * Si x esta, es eliminado. */ //no esta la implementacin......(Tarea) /* * Determinar el elemento ms pequeo en el arbol.. * Devuelve: el dato ms pequeo o null, * en el caso que el arbol este vacio. * Analogamente se podra determinar el ms grande elemento en el arbol */



28

//no esta implementado.....(Tarea) /* * Eliminar el arbol. */ //no esta implementado....(Tarea) /* * Test, si el arbol esta vacio o no. * devuelve true, caso de vacio; sino false. */ public boolean esVacio( ) { return raiz == null; } /* * Entregar el contenido del rbol en una sucesion ordenada. */ public void printArbol( ) { if( esVacio( ) ) System.out.println( "Arbol vacio" ); else printArbol( raiz ); } /* * Salida de los elementos del arbol binario rotados en 90 grados */ public void salidaArbolBinario() { if( esVacio() ) System.out.println( "Arbol vacio" ); else salidaArbolBinario(raiz,0); } /* * Metodo interno para tomar un nodo del arbol. * Parametro b referencia al nodo del arbol. * Devuelve los elementos o null, * caso de b sea null. */ private Comparable elementAt(Nodo_Avl b ) { return b == null ? null : b.datos; } /* * Metodo Interno para agregar o insertar un nodo en un subarbol. * x es el elemento a agregar. * b es el correspondiente nodo raiz. * Devuelve la nueva raiz del respectivo subarbol. */ private Nodo_Avl insertar(Comparable x, Nodo_Avl b) { if( b == null ) b = new Nodo_Avl(x, null, null); else if (x.compareTo( b.datos) < 0 ) { b.izq = insertar(x, b.izq ); if (altura( b.izq ) - altura( b.der ) == 2 ) if (x.compareTo( b.izq.datos ) < 0 ) b = RotacionSimpleIzq(b); else



29

b = RotacionDobleIzq_Der(b); } else if (x.compareTo( b.datos ) > 0 ) { b.der = insertar(x, b.der); if( altura(b.der) - altura(b.izq) == 2) if( x.compareTo(b.der.datos) > 0 ) b = RotacionSimpleDer(b); else b = RotacionDobleDer_Izq(b); } else ; // Duplicados; no hace nada b.altura = max( altura( b.izq ), altura( b.der ) ) + 1; return b; } /* * Metodo Interno para determinar el dato ms pequeo. * b es la raiz. * Devuelve: Nodo con el elemento mas pequeo. */ private Nodo_Avl hallarMin(Nodo_Avl b) { if (b == null) return b; while(b.izq != null ) b = b.izq; return b; } /* * Analogamente al anterior pero el ms grande. */ private Nodo_Avl hallarMax(Nodo_Avl b ) { if (b == null) return b; while (b.der != null) b = b.der; return b; } /* * Metodo interno para determinar un dato. * x es el dato buscado * b es la raiz * Devuelve: Nodo con el correspondiente dato. */ private Nodo_Avl hallar(Comparable x, Nodo_Avl b) { while( b != null ) if (x.compareTo( b.datos) < 0 ) b = b.izq; else if( x.compareTo( b.datos ) > 0 ) b = b.der; else return b; // paso return null; // no paso nada } // recorrido en Inorden



30

private void printArbol(Nodo_Avl b) { if( b != null ) { printArbol( b.izq ); System.out.println( b.datos ); printArbol( b.der ); } } /* * salida del arbol binario rotado en 90 Grados */ private void salidaArbolBinario(Nodo_Avl b, int nivel) { if (b != null) { salidaArbolBinario(b.izq, nivel + 1); for (int i = 0; i < nivel; i++) { System.out.print(' '); } System.out.println(b.datos); salidaArbolBinario(b.der, nivel + 1); } } /* * Salida: altura de los nodos, o -1, en el caso null. */ private static int altura(Nodo_Avl b) { return b == null ? -1 : b.altura; } /* * Salida: Maximum entre lhs y rhs. */ private static int max( int lhs, int rhs ) { return lhs > rhs ? lhs : rhs; } /* * Rotacion Simple Izquierda(simetrica a Rotacion Simple Derecha). * Para los arboles AVL, esta es una de las simples rotaciones. * Actualiza la altura, devuelve la nueva raiz. */ private static Nodo_Avl RotacionSimpleIzq(Nodo_Avl k2) { Nodo_Avl k1 = k2.izq; k2.izq = k1.der; k1.der = k2; k2.altura = max( altura( k2.izq ), altura( k2.der ) ) + 1; k1.altura = max( altura( k1.izq ), k2.altura ) + 1; return k1; } /* * Rotacin Simple Derecha. */ private static Nodo_Avl RotacionSimpleDer(Nodo_Avl k1) { Nodo_Avl k2 = k1.der; k1.der = k2.izq; k2.izq = k1; k1.altura = max( altura( k1.izq ), altura( k1.der ) ) + 1; k2.altura = max( altura( k2.der ), k1.altura ) + 1;



31

return k2; } /* * Rotacion doble: primero hijo izquierdo con su hijo derecho * entonces nodo k3 con el nuevo hijo izquierdo. * para los arboles AVL, esta es una doble rotacin * actualiza alturas, entrega nueva raiz. */ private static Nodo_Avl RotacionDobleIzq_Der(Nodo_Avl k3) { k3.izq = RotacionSimpleDer( k3.izq ); return RotacionSimpleIzq( k3 ); } /* * rotacion doble: primero hijo derecho * con su hijo izquierdo; luego nodo k1 con nuevo hijo derecho. * Para los AVL, esta es una doble rotacin. * actualiza alturas, entrega nueva raiz. */ private static Nodo_Avl RotacionDobleDer_Izq(Nodo_Avl k1) { k1.der = RotacionSimpleIzq(k1.der); return RotacionSimpleDer(k1); } } //En archivo Nodo_Avl.java // Declaracin de la clase Nodos para los elementos en los arbol AVL. class Nodo_Avl { // Instancias protected Nodo_Avl izq; // hijo izquierdo protected Nodo_Avl der; // hijo derecho protected int altura; // altura public Comparable datos; // los datos como elementos del arbol avl // Constructores public Nodo_Avl(Comparable datElem) { this(datElem, null, null ); } public Nodo_Avl( Comparable datElem, Nodo_Avl ib, Nodo_Avl db ) { datos = datElem; izq = ib; der = db; altura = 0; } }



32

La implementacin de los rboles AVL, as como su salida estn basados en los ejemplos dados. Para interpretar la salida considerar que se debe girar el rbol resultante de los datos 0, 1, 2, 3, 4, 5, 6, ya que los otros son al azar.

Propuestas de mejora: Una mejora factible de considerar en la implementacin del mtodo insertar es considerar que los elementos a ingresar son String o caracteres, adems de considerar el factor de balance y la nueva raz que se obtiene. Como se muestra en el ejemplo siguiente. carcter que desea insertar al arbol-AVL (Borrar: \n): a a insertado AVL con balanceo: a(0) carcter que desea insertar al arbol-AVL (Borrar: \n): b b insertado AVL con balanceo: b(0) a(1) c insertado AVL con balanceo: c(0)



33

b(0) a(0) HEAP Este segmento es copia fiel del libro CLRS The (binary) heap data structure is an array object that can be viewed as a nearly complete binary tree (see Section B.5.3), as shown in Figure 6.1. Each node of the tree corresponds to an element of the array that stores the value in the node. The tree is completely filled on all levels except possibly the lowest, which is filled from the left up to a point. An array A that represents a heap is an object with two attributes: length[A], which is the number of elements in the array, and heap-size[A], the number of elements in the heap stored within array A. That is, although A[1 .. length[A]] may contain valid numbers, no element past A[heap-size[A]], where heap-size[A] length[A], is an element of the heap. The root of the tree is A[1], and given the index i of a node, the indices of its parent PARENT(i), left child LEFT(i), and right child RIGHT(i) can be computed simply:

A max-heap viewed as (a) a binary tree and (b) an array. The number within the circle at each node in the tree is the value stored at that node. The number above a node is the corresponding index in the array. Above and below the array are lines showing parent-child relationships; parents are always to the left of their children. The tree has height three; the node at index 4 (with value 8) has height one. MAX-HEAPIFY is an important subroutine for manipulating max-heaps. Its inputs are an array A and an index i into the array. When MAX-HEAPIFY is called, it is assumed that the binary trees rooted at LEFT(i) and RIGHT(i) are max-heaps, but that A[i] may be smaller tan its children, thus violating the max-heap property. The function of MAX-HEAPIFY is to let the value at A[i] "float down" in the max-heap so that the subtree rooted at index i becomes a max-heap.



34

The action of MAX-HEAPIFY(A, 2), where heap-size[A] = 10. (a) The initial configuration, with A[2] at node i = 2 violating the max-heap property since it is not larger than both children. The max-heap property is restored for node 2 in (b) by exchanging A[2] with A[4], which destroys the max-heap property for node 4. The recursive call MAXHEAPIFY( A, 4) now has i = 4. After swapping A[4] with A[9], as shown in (c), node 4 is fixed up, and the recursive call MAX-HEAPIFY(A, 9) yields no further change to the data structure.

shows an example of the action of BUILD-MAX-HEAP.



35

The operation of BUILD-MAX-HEAP, showing the data structure before the call to MAX-HEAPIFY in line 3 of BUILD-MAX-HEAP. (a) A 10-element input array A and the binary tree it represents. The figure shows that the loop index i refers to node 5 before the call MAX-HEAPIFY(A, i). (b) The data structure that results. The loop index i for the next iteration refers to node 4. (c)-(e) Subsequent iterations of the for loop in BUILD-MAXHEAP. Observe that whenever MAX-HEAPIFY is called on a node, the two subtrees of that node are both max-heaps. (f) The max-heap after BUILD-MAX-HEAP finishes.



36

heapsort algorithm como Aplicacin de los Heap.

The operation of HEAPSORT. (a) The max-heap data structure just after it has been built by BUILD-MAX-HEAP. (b)-(j) The max-heap just after each call of MAXHEAPIFY in line 5. The value of i at that time is shown. Only lightly shaded nodes remain in the heap. (k) The resulting sorted array A. The HEAPSORT procedure takes time O(n lg n), since the call to BUILD-MAX-HEAP takes time O(n) and each of the n - 1 calls to MAX-HEAPIFY takes time O(lg n). Arbol Red-Black



37

Introduccin: Supongamos que se desea tener un Buscador de Direcciones de Email, el cual almacena nombres y direcciones de e-mail en un archivo map basado en la clase java.util.TreeMap definida en el JDK 1.2. La clase TreeMap crea una estructura de datos llamada "red-black tree", en el cual, los datos son almacenados con una clave y un valor, es decir, el nombre es la clave y la direccin e-mail el valor. Cuando aadimos una entrada al archivo map, introducimos tanto un nombre (la clave) como una direccin e-mail (el valor). De manera que, podemos buscar o borrar una direccin e-mail introduciendo slo un nombre. El nombre no puede ser null porque es una clave. Si un usuario intenta introducir un nombre null, la aplicacin lanza una excepcin y muestra una pgina de error. Esta es una aplicacin en donde se utilizan la estructura de datos Red-Black para organizar los datos. Un rbol rojo-negro es un rbol binario extendido, en donde los nodos pueden ser ramas u hojas. Los nodos hojas son los nodos que hay al final de una lnea, mientras que los nodos ramas son los nodos ms grandes que conectan con dos o ms lneas. Los nodos se almacenan en una estructura compensada en el rbol, usando las siguientes condiciones:

1. Cada nodo tiene dos hijos o es una hoja. 2. Cada nodo est coloreado en rojo en negro. 3. Cada nodo hoja est coloreado en negro. 4. Si un nodo es rojo, sus dos hijos son negros. 5. Cada camino desde el raz hasta una hoja contiene el mismo nmero de nodos negros.

Ejemplo Aqu vemos un Red-Black vlido, y otro que no lo es.

Todo nodo es ya sea red (circulo) black (cuadrado) La raz es black, Toda hoja (leaf ) es black, a pesar que no se vean, Si un nodo es red, entonces ambos hijos son black - dos nodos red pueden no ser adyacentes. - Pero si un nodo es black, sus hijos pueden ser red o black, Para todo nodo, todos los caminos (paths) desde l a sus descendientes contienen el mismo n de nodos black. Observar que todo AVL tree es tambin un Red-Black tree, sin embargo no todo Red-Black tree es necesariamente un AVL. Notar que una de la diferencia fundamental es que los AVL tree tienen altura de log(n), mientras que los Red-Black tree tienen altura menor o igual a 2log(n+1). La ventaja de un rbol Red_Black en el contexto de Buscador de Direcciones de E-mail es que podemos crear un archivo map que almacena datos en orden ascendente (ordenados por claves) y que tiene tiempos de bsqueda rpidos. Una relacin interesante de los Red-Black con otro tipo de rbol es con los rbol 2-3-4, los que pueden representarse como rboles binarios.



38

La idea comprende, representar 3-nodos y 4-nodos como rbol binario, los que a travs de arcos rojos pueden ser unidos tal como lo muestra la figura,

Ejemplo: Transformar el rbol siguiente en un Red-Black



39

Desde un punto de vista ms tcnico, digamos que la librera Collection posee un map, que corresponde a una coleccin de datos, cuya naturaleza consta de dos partes: una clave nica, la que maps al valor correspondiente un valor, el cual puede no ser nica. Un map de alumnos, en donde la clave, que es nica (n ID del alumno) y el resto es el valor del alumno (ficha asociada a l, o el promedio de notas de un curso).

Llamaremos altura negra ( black-height bh(x) ) de un nodo x, al nmero de nodos negros desde x a una hoja, no incluyendo a x. Se definir como altura negra de un RB-Tree a la altura negra de su raz. Se asumir que la raz de un RB-Tree es negra. La altura negra del RB-Tree de la Figura 1, es 3.

= red = black

10

20

30

40

50

60

70

80

90

100

110

120

130

140

150

160

170

0 0 0 0

0 0

0 0 0 0

0 0

0 0

0 0 0 0

1 1

1

1 1

1

1

1 1

1

2

2

2

2

32

3

Algunos nmeros de inters. a) Cualquier rbol Red-Black, con raz x, tiene al menos n = 2bh(x) 1 nodos internos, donde bh(x) es la altura negra del nodo x. b) En un rbol Red-Black, al menos la mitad de los nodos sobre cualquier camino desde la raz a la hoja debe ser negro. Con esto se puede probar que un rbol Red-Black con n-nodos internos tiene altura h 2log(n -1). En efecto, basado en b), podemos inferir que si h es la altura de un rbol Red-Black, entonces bh(x) h/2, luego n 2h/2 1, n 1 2h/2, log(n-1) h/2 y finalmente 2 log(n-1) h. En consecuencia este resultado establece que la altura de los rboles Red-Black es O(log(n)). De donde se tiene que el costo de insercin es

O(log(n)) para descender al punto de insercin, O(1), para hacer la insercin y O(log(n)) para ascender.

As como tambin se puede afirmar que la bsqueda esta garantizada que sea bajo logN.

INSERTAR La insercin es igual que el insertado en un ABB, pero con la propiedad de que el nodo insertado siempre va ser rojo. Luego de tener insertado el nodo en el rbol se rompe la propiedad Red-Black



40

si y solo si el padre es rojo, si el padre es negro no existen problemas. Sin embargo, existen una serie de casos a estudiar. Por lo pronto digamos que insertar en un arbol RED-BLACK es de costo (log n). Ejemplo A continuacin se muestra una sucesin de inserciones a partir de un Red-Black inicialmente vaco. Los datos a insertar son 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15.

, , , ,

, , Y a continuacin se muestra la salida para una propuesta de implementacin que usa la interface Comparable y la interpretacin que se le debe dar a la salida para relacionarlo con los rboles Red-Black, es decir, es un par ordenado (a, b) en donde la primera componente es el valor ingresado y la segunda componente es ya sea 1(black) o 0(red).

,



41

,

,

,

,

,

,



42

.

/* * Implementacin de un Arbol_RB. * Las comparaciones estn basadas en el mtodo compareTo. */ public class Arbol_RB { private Nodo_RB base; // nodo bsico private static Nodo_RB nullNode;



43

{ nullNode = new Nodo_RB(null); nullNode.izq = nullNode.der = nullNode; } static final int BLACK = 1; // Black debe ser 1 static final int RED = 0; // Para "insertar" se necesitan private static Nodo_RB actual; private static Nodo_RB padre; private static Nodo_RB relac1; //relac1 es la relacin entre los nodos private static Nodo_RB relac2;//relac1 es la relacin entre los nodos /* * Construccin del Arbol. * negInf es un valor, el que es menor o igual a todos los otros valores. */ public Arbol_RB(Comparable negInf) { base = new Nodo_RB(negInf); base.izq = base.der = nullNode; } /* * agregar en el RB. Duplicados no sern considerados. * "item" es el dato que se agrega. */ public void insert(Comparable item) { actual = padre = relac1 = base; nullNode.dat = item; while( actual.dat.compareTo( item ) != 0 ) { relac2 = relac1; relac1 = padre; padre = actual; actual = item.compareTo(actual.dat ) < 0 ? actual.izq : actual.der; // Probar si dos hijos R; en caso de si, fijarlo if( actual.izq.color == RED && actual.der.color == RED ) reOrientar( item ); } // campo para agregar, en caso de if( actual != nullNode ) return; actual = new Nodo_RB( item, nullNode, nullNode ); // colgar de su padre if( item.compareTo( padre.dat) < 0 ) padre.izq = actual; else padre.der = actual; reOrientar( item ); } /* * eliminar no esta implementado * x es el dato a eliminar. */ public void remove( Comparable x ) { System.out.println("Eliminar no esta implementado."); } /* * hallar el min elemento en el RB. * devuelve el elemento ms pequeo o null, en caso vaco.



44

*/ public Comparable findMin( ) { if (isEmpty( )) return null; Nodo_RB itr = base.der; while( itr.izq != nullNode ) itr = itr.izq; return itr.dat; } /* * hallar el elemento ms grande en el RB. * devuelve el elemento ms grande, o null, en caso vaco. */ public Comparable findMax( ) { if (isEmpty( )) return null; Nodo_RB itr = base.der; while( itr.der != nullNode ) itr = itr.der; return itr.dat; } /* * hallar un elemento en el RB. * x es el elemento buscado. * devuelve el elemento respectivo o null,en el caso que no sea encontrado. */ public Comparable find(Comparable x) { nullNode.dat = x; actual = base.der; for( ; ; ) { if( x.compareTo( actual.dat ) < 0 ) actual = actual.izq; else if( x.compareTo( actual.dat ) > 0 ) actual = actual.der; else if( actual != nullNode ) return actual.dat; else return null; } } /* * hacer el RB vaco. */ public void makeEmpty( ) { base.der = nullNode; } /* * Test, o si el RB esta vaco o no. * devuelve true, en el caso vaco; en otro caso false. */ public boolean isEmpty( ) { return base.der == nullNode; } /* * salida del RB en orden. */ public void printTree( )



45

{ if( isEmpty() ) System.out.println("Arbol vaco"); else printTree( base.der ); } /* * uno de los mtodos de lectura inorden. * b es la raz del RB. */ private void printTree(Nodo_RB b) { if (b != nullNode ) { printTree(b.izq); System.out.println(b.dat ); printTree(b.der); } } /* * salida del RB con una rotacion de 90 Grados. */ public void salidaArbol_RB() { salidaArbol_RB(base.der,0); } private void salidaArbol_RB(Nodo_RB b, int nSpace) { if (b != nullNode) { salidaArbol_RB(b.izq,nSpace += 6); for (int i = 0; i < nSpace; i++) System.out.print(" "); System.out.println(b.dat + " " + b.color); salidaArbol_RB(b.der, nSpace); } } /* * rutina que permite en el caso de que un nodo tenga 2 hijos * los lleva a cambiar de color y rotar. * item contiene el dato a incorporar. */ private void reOrientar(Comparable item) { // cambiar color actual.color = RED; actual.izq.color = BLACK; actual.der.color = BLACK; if (padre.color == RED) // Rotacin es necesaria { relac1.color = RED; if ( (item.compareTo( relac1.dat) < 0 ) != (item.compareTo( padre.dat) < 0 ) ) padre = rotacion(item, relac1); // parte la doble rotacin actual = rotacion(item, relac2); actual.color = BLACK; } base.der.color = BLACK; // hace la raz negra } /* * rutina para una simple o doble rotacin. * "item" es el dato a reOrientar. * "padre" es el "padre" de la raz de los sub arboles rotados.



46

* devuelve: la raz de los sub arboles rotados. */ private Nodo_RB rotacion(Comparable item, Nodo_RB padre) { if (item.compareTo(padre.dat) < 0) return padre.izq = item.compareTo( padre.izq.dat) < 0 ? rotacionCon_descen_izq(padre.izq) : // LL rotacionCon_descen_der(padre.izq) ; // LR else return padre.der = item.compareTo(padre.der.dat) < 0 ? rotacionCon_descen_izq(padre.der) : // RL rotacionCon_descen_der(padre.der); // RR } /* * Rotacin Nodo_AB con descendiente a la izq. */ static Nodo_RB rotacionCon_descen_izq( Nodo_RB k2 ) { Nodo_RB k1 = k2.izq; k2.izq = k1.der; k1.der = k2; return k1; } /* * Rotacin Nodo_AB con descendiente a la der. */ static Nodo_RB rotacionCon_descen_der(Nodo_RB k1) { Nodo_RB k2 = k1.der; k1.der = k2.izq; k2.izq = k1; return k2; } } import java.io.*; public class Arbol_RBTest { public static void main(String[ ] args) { InputStreamReader isr = new InputStreamReader(System.in); BufferedReader ein = new BufferedReader(isr); String entrada_datos = null; Arbol_RB b = new Arbol_RB(new Integer(Integer.MIN_VALUE)); System.out.println("Ingrese los datos: "); while (true) { try { entrada_datos = ein.readLine(); int a = Integer.parseInt(entrada_datos); if (a == 0) break;//no admite al cero como entrada b.insert(new Integer(a)); b.salidaArbol_RB(); } catch(IOException e) { System.out.println(e.toString()); System.exit(0); } } b.printTree(); b.salidaArbol_RB();



47

} } Ejemplo: Veamos como se relacionan las claves "10 85 15", con la propuesta de implementacin de rbol red-black. Estado de inicio

public Arbol_RB(Comparable negInf) { base = new Nodo_RB(negInf); base.izq = base.der = nullNode; }

Veamos que pasa con el rbol RB luego de la declaracin b.insert(new Integer(10)).

Prosigamos con la declaracin b.insert(new Integer(85)).



48

Y, veamos que pasa con b.insert(new Integer(15))

Notar que Rotacin es necesaria! Sobre el padre, se tiene padre = rotacion(item,relac1), de donde padre.der = rotacionCon_descen_izq(padre.der).



49

Luego de esta rotacin contina otra rotacin y esta vez sobre, actual = rotacion(item, relac2) y padre.der = rotacionCon_descen_der(padre.der) Estado Final

Eliminacin: La eliminacin de un dato en un rbol RED-BLACK consta de dos pasos, primero se procede con el mismo mtodo de eliminacin en un ABB normal, es decir buscar el elemento a eliminar y remplazarlo por el mayor de sus descendientes reduciendo el problema a la eliminacin de una hoja; luego se procede a restablecer las propiedades para el balanceo de un RED-BLACK. Sin embargo, existen una serie de casos a estudiar. Arboles B-Tree Introduccin: Pensar en establecer una suerte de balanceo resulta a la postre un costo muy superior al de los rboles binarios, sin embargo, los rboles Red-Black proponen una buena forma de optimizar en trminos de ahorro en las Rotaciones, sin embargo, para aquellos rboles de grado



50

mayor que 2, resulta un tanto ms complicado buscar la forma de optimizarlos, de all entonces que la opcin de usar otros rboles como alternativa. Otro tipo de rboles, llamados rboles multicaminos o M-Way son tambin muy utilizados en la construccin y mantenimiento de rboles de bsqueda con gran cantidad de datos o nodos, y por tanto, usualmente almacenados en memoria secundaria, en donde en este caso el acceso al disco, as como la rapidez para encontrar la informacin, es un problema no menor. Como ya se menciono, en los almacenamientos en memoria secundaria el costo ms significativo viene dado por el acceso a este tipo de memoria, muy superior al tiempo necesario para acceder a cualquier posicin de memoria principal. Entonces al tratarse de un dispositivo perifrico, y por tanto, de acceso lento, resulta primordial minimizar en lo posible el nmero de accesos. Por ejemplo, para almacenar un milln de elementos en memoria secundaria, con un rbol binario, el nmero promedio de accesos es del orden log 2106 aprox. 20 accesos, en donde AVL o Red-Black no mejoran substancialmente este record. Sin embargo los rboles multicaminos mejoran este nmero de accesos, pues se organizan de tal manera que un rbol se subdivide en subrboles y stos se representan como unidades a las que se accede simultneamente, estos subrboles se les llama pginas, cada acceso a pgina requiere un nico acceso a memoria secundaria. De manera que si almacenamos 100 nodos por pgina se necesitarn en promedio log 100106 aprox. 3 accesos a memoria secundaria para buscar en un milln de elementos. No obstante esta forma de distribuir la informacin no garantiza que el rbol se degenere, es decir en el peor de los casos, los accesos sern 104. Nuevamente se hace imprescindible un criterio de crecimiento armnico que garantice cierto equilibrio, que se logra en las aplicaciones en Base de Datos. Los datos como ya mencionamos son almacenados sobre el disco en bloques, (blocks) con un nmero fijo de bytes. Todo bloque por otro lado puede tener muchos registros (record). Un registro corresponde al dato almacenado en el nodo exterior o interior, un nodo por registro. Ahora, el tiempo requerido para acceder al bloque es relativamente largo, pues el cabezal debe desplazarse sobre el cilindro apropiado y el bloque debe entonces rotar con alguna velocidad para posicionarse bajo el cabezal. Una vez que el disco esta posicionado sobre el bloque, el bloque entero es accesado (leer o escribir). El dato ms pequeo que puede ser accesado sobre el disco es un bloque. Veamos a continuacin una breve introduccin de los datos ms relevantes en la organizacin y acceso a la informacin guardada en una base de datos. Organizacin Fsica de los Sistemas de Base de Datos. La organizacin fsica de una base de datos es un tpico extenso y se aborda en detalle, principalmente en la asignatura Base de Datos, y digo principalmente pues tambin se trata en sistema operativo y sistemas de software. Sin embargo, el rendimiento general de un sistema de base de datos se determina en gran medida por las estructuras de datos fsicas usadas y por la eficiencia con la cual el sistema trabaja sobre las mismas. Aunque los usuarios no siempre deban tener conocimiento de los detalles del diseo fsico de la base de datos, sin embargo Ud. deberan saber que stos afectan al rendimiento, un factor de gran importancia en la satisfaccin del usuario con el sistema de base de datos. Una pregunta nos asalta, Podra el usuario obtener la informacin deseada en el formato apropiado y en un tiempo conveniente?. Esta ltima frase, "tiempo conveniente", puede expresarse generalmente como tiempo de respuesta aceptable. La "informacin deseada" y el "formato apropiado" no se afectan mucho por la organizacin fsica de la base de datos, pero el tiempo de respuesta s. El tiempo de respuesta es el tiempo transcurrido entre la iniciacin de una operacin sobre la base de datos y la disponibilidad



51

del resultado. Un tiempo de respuesta lento es la queja ms frecuente que expresan los usuarios de los sistemas de bases de datos, posiblemente debido a que es lo que se observa ms fcilmente. Un buen diseo fsico de la base de datos almacenara datos de forma que puedan recuperarse, actualizarse y manipularse en el mnimo tiempo posible. En este segmento me interesa abordar aspectos de la organizacin fsica de la base de datos que soportan la eficiencia de las operaciones en las mismas. Acceso fsico a la base de datos

En la figura anterior, se muestra el sistema para el acceso fsico a la base de datos. Se puede ver la interaccin del usuario con el sistema de base de datos al iniciar una consulta o demanda. El selector de estrategia (usualmente el software que transforma una consulta del usuario en una forma efectiva para su posterior ejecucin) traduce la orden del usuario a su forma ms eficiente para su ejecucin. La orden traducida activa entonces al administrador de buffer, que controla el movimiento de datos entre la memoria principal y el almacenamiento en disco. El administrador de archivos da soporte al administrador de buffer administrando la reserva de localizaciones de almacenamiento en disco y las estructuras de datos asociadas. Adems de los datos del usuario, el disco contiene el diccionario de datos, que define la estructura de los datos del usuario y cmo stos pueden usarse. Los datos del usuario se almacenan como una base de datos fsica o coleccin de registros. Formas de almacenamiento fsico La memoria principal es el almacenamiento intermedio usado por los datos que estn disponibles para las operaciones del usuario. Aqu es donde reside la ejecucin del programa y como los datos se necesitan por el programa para ejecutar sus funciones, se transmiten estos desde el almacenamiento secundario a la memoria principal. Aunque la memoria principal puede ser capaz de almacenar varios megabytes de datos, es normalmente muy pequea para almacenar la base de datos completa, por lo que es necesario el almacenamiento secundario. El almacenamiento secundario para los sistemas, de base de datos est compuesto generalmente por el almacenamiento en disco y el almacenamiento en cinta magntica. Casi siempre, la base de datos completa se almacena en disco y porciones de sta se transfieren desde el disco a la memoria primaria, a medida que se necesita. El almacenamiento en disco es la forma principal de almacenamiento con acceso directo, por lo que los registros individuales se pueden acceder directamente. Aunque el



52

almacenamiento en cinta magntica es menos costoso que el almacenamiento en disco, los registros pueden ser solamente accedidos secuencialmente (y ms lentamente que en disco). Su funcin en el sistema de base de datos est bsicamente limitada a archivar datos. La unidad fsica en la que est contenido el medio de grabacin del disco se llama controlador de disco (disk driver). El controlador de disco contiene un paquete de disco o volumen, el cual est formado por un conjunto de superficies grabables (discos) montados sobre un eje. En operacin, el eje y los discos rotan a una alta velocidad. Los datos se graban sobre las pistas, que son coronas circulares grabables encontradas sobre cada superficie, tal como lo muestra la siguiente figura.

Una metfora para tal descripcin es que el paquete de disco es una pila de discos musicales sobre un eje, excepto que aqu las pistas son concntricas y no en forma de espiral interna hacia el centro. Un conjunto de cabezas de lectura/escritura ubicadas al final de un brazo, simblicamente como los dientes de un peine, se mueven como un grupo, de tal forma que stos pueden ser posicionados sobre todas las pistas del mismo radio. El conjunto de dichas pistas se denomina cilindro. Es decir, conceptualmente, un conjunto de pistas del mismo dimetro rotando a alta velocidad forma un cilindro. Esta definicin es muy til, ya que cualquier posicionamiento de un conjunto de cabezas de lectura/escritura puede ser descrito por la localizacin del cilindro (por ejemplo, cilindro 199). Por lo que todas las pistas del cilindro especificado se pueden escribir o leer, sin un movimiento adicional de las cabezas de lectura/escritura. La direccin de un registro del disco normalmente necesita informacin sobre el nmero del cilindro, de la superficie y del bloque. Bloques de almacenamiento fsico El registro fsico o bloque es la unidad de dato ms pequea en un disco que es fsicamente direccionable, vea la figura anterior, en donde cada pista en una superficie est compuesta de un nmero de bloques. Un bloque puede contener uno o ms registros lgicos. Ejemplo: Supongamos que tenemos un factor de compactacin de 3, esto significa que en cada bloque se almacenan tres registros lgicos. Supongamos que deseamos recuperar el registro Juan Perez almacenado en la siguiente direccin, N cilindro = 5, N superficie = 2, N bloque =1 . Entonces, para recuperar el registro Juan Perez, las cabezas de lectura/escritura se mueven sobre el cilindro 5 (pista 5 en todas las superficies). Entonces se activan las cabezas de lectura/escritura para la superficie nmero 2 y se leen los nmeros de bloques a la vez que la pista gira sobre las cabezas. Cuando se detecta el bloque 1, el bloque entero de tres registros lgicos se lee en memoria principal, donde se selecciona el registro Juan Perez. En nuestro ejemplo suponemos la estructura ms general de un disco, donde las cabezas de lectura/escritura estn sujetas a un brazo movible. No todas las unidades de disco estn



53

configuradas de esta forma. En algunas, las cabezas de lectura/escritura son fijas para cada cilindro. Tpicamente estas unidades son ms costosas, pero ms rpidas, debido a que no hay retraso en mover las cabezas de lectura/escritura sobre un nuevo cilindro. Generalmente, el tiempo necesario para ejecutar clculos en un bloque es mucho menor que el necesario para transferir los datos entre el almacenamiento secundario y el primario. Sin embargo, una buena estrategia de diseo es identificar, donde sea posible, los registros lgicos que probablemente se usan en las mismas operaciones y agruparlos en bloques. Ejemplo: Supongamos que una firma almacena tres tipos de alambres, A, B y C, y que se entregan en el mismo cargamento. Si cada bloque contiene tres registros y los registros A, B y C se almacenan en bloques separados, se necesitaran tres operaciones de entrada/salida (E/S) para actualizarlos. Sin embargo, si se agrupan en el mismo bloque, entonces slo es necesaria una operacin de E/S. Debido a que generalmente el acceso a disco es un cuello de botella en las operaciones de acceso a una base de datos, una asignacin cuidadosa de los registros en los bloques puede mejorar significativamente el tiempo de respuesta. Factores de Rendimiento del Disco En general, hay cuatro factores que directamente afectan a la velocidad, con la que los datos se transfieren a y desde el almacenamiento en disco: tiempo de posicionamiento (access motion time), tiempo de activacin de la cabeza, re

Arboles Fit 2011

Documents

Transcript of Arboles Fit 2011