estructura de datos y arboles equilibrados

5/20/2018 Estructura de Datos y Arboles Equilibrados

1/27

Estructura de Datos y rboles Equilibrados

(Octubre -2011)

ContenidoINTRODUCCIN ....................................................................................................................................... - 1 -

EQUILIBRIO .............................................................................................................................................. - 1 -

RBOL AVL ............................................................................................................................................... - 2 -

CUNDO REORGANIZAR UN RBOL AVL .......................................................................................................... -2-

BALANCE ................................................................................................................................................ -2-

ROTACIONES ............................................................................................................................................ -3-

Ejercicio grfico ................................................................................................................................ - 5 -

IMPLEMENTACIN DE UN RBOL AVL ..................................................................................................... - 8 -

CDIGO DE NODEAVL ............................................................................................................. -8-

CDIGO DE BALANCEDTREE .................................................................................................... -10-

CDIGO PARA PROBAR UN BALANCEDTREE ................................................................................. -23-

EJERCICIO ............................................................................................................................................... - 24 -

CLASE PALABRA ...................................................................................................................................... -24-

MTODO PARA CONTAR PALABRAS .............................................................................................................. -26-

CONCLUSIN ......................................................................................................................................... - 26 -


2/27


- 1 -

Introduccin

En esta publicacin continuamos con el tema de los rboles y nos introducimos en lo que seconoce como rboles equilibrados.

Equilibrio

La distancia de un nodo a la raz determina la eficiencia con la que se puede localizar el nodo.Dado cualquier nodo de un rbol, a sus hijos se puede acceder siguiendo slo un camino debifurcacin o de ramas. Esta caracterstica se conoce como balanceo equilibrio. Para determinarsi un rbol est equilibrado, se calcula su factor de equilibrio.

El factor de equilibrio de un rbol binario es la diferencia en altura entre los subrboles derecho eizquierdo.

Un rbol est perfectamente equilibradosi su equilibrio o balance es cero y sus subrboles son

tambin perfectamente equilibrados. Dado que esta situacin no se presenta frecuentemente, seutiliza una definicin alternativa que dice: un rbol binario est equilibrado si la altura de sussubrboles difiere en no ms de uno y sus subrboles son tambin equilibrados.

Existe una definicin de rbol perfectamente balanceado, que dice: "un rbol perfectamentebalanceado es aquel en el que para cada nodo el nmero de nodosen sus subrboles derecho eizquierdo difieren como mximo en uno". Esta es la mxima expresin del equilibrio, sin embargoel costo (en procesamiento) para mantener este tipo de rboles es demasiado por ello la industriaacepta y opera con el concepto de rbol equilibrado, en el quepara cada nodo las alturas de lossubrboles derecho e izquierdo difieren en no ms de uno en valor absoluto.

Los siguientes esquemas muestran las diferencias entre cada concepto (definicin):

Perfectamente Equilibrado Perfectamente Balanceado Equilibrado

Fueron Adelson-Velskii y Landis quienes propusieron una solucin que se conoce como rbol AVLla que permite mantener un rbol equilibrado cada vez que se agrega o extrae un nodo. En estasolucin cuando se realiza la bsqueda de un elemento, en el peor de los casos se requiere 44%ms comparaciones que en un rbol perfectamente balanceado de igual altura, esto es as porquelos subrboles difieren como mximo en 1 en sus alturas pero la cantidad de nodos puede ser muyvariable; La industria prefiere esta implementacin o sus variantes dado que es menos costosa a lahora de reorganizar el rbol de manera que mantenga la estructura adecuada.

Los resultados empricos (Knuth, 1998) muestran que para un nmero "n" grande de nodos elnmero promedio de accesos en una bsqueda es del orden de ln(n) + 0.25; de manera quedefinitivamente vale la pena estudiar los rboles AVL.


3/27


- 2 -

rbol AVL

Un rbol AVL es aquel en el que para cada nodo las alturas de los subrboles derecho e izquierdodifieren en no ms de uno en valor absoluto.

Indudablemente se trata de un tipo de dato abstracto cuya implementacin se logra mediante unrbol binario de bsqueda, en el que se modifica el comportamiento para agregar y extraerelementos asegurando que la diferencia de altura entre los subrboles derecho e izquierdo decada nodo no sea mayor a uno en valor absoluto.

Para asegurar que la diferencia de altura entre los subrboles de cada nodo no sea mayor a uno envalor absoluto es necesario "reorganizar" la forma del rbol binario de bsqueda despus deagregar o extraer un nodo que provoque un cambio en las alturas de alguno de los subrboles.

Cundo reorganizar un rbol AVL

No siempre hace falta reorganizar la forma del rbol, a continuacin se muestra una mnimadeduccin que indica los casos en que es obligatorio reorganizar la forma del rbol:

Se defina hDcomo altura del subrbol derecho y hIcomo altura del subrbol izquierdo.Si hD < hIy agrego en el subrbol derecho cambiando su altura entonces hD = hI.

Si hD = hIy agrego en el subrbol derecho cambiando su altura entonces hD > hI.

Si hD > hIy agrego en el subrbol derecho cambiando su altura entonces hD >> hI.

Solamente cuando la altura derecha es mayor que la altura izquierda y se agrega un nodo en el

subrbol derecho que cambia la altura del mismo se debe reorganizar el rbol.

A continuacin se analiza la situacin semejante para cuando se agrega en el subrbol izquierdo.

Si hI < hDy agrego en el subrbol izquierdo cambiando su altura entonces hI = hD.

Si hI = hDy agrego en el subrbol izquierdo cambiando su altura entonces hI > hD.

Si hI > hDy agrego en el subrbol izquierdo cambiando su altura entonces hI >> hD.

Solamente cuando la altura izquierda es mayor que la altura derecha y se agrega un nodo en el

subrbol izquierdo que cambia la altura del mismo se debe reorganizar el rbol.

Balance

Si en cada nodo se define el concepto de "Balance" como la diferencia entre la altura del subrbolderecho menos la altura del subrbol izquierdo:

Balance = hD - hILos valores posibles de balance pueden ser:

Balance = 1implica que altura subrbol derecho mayor que altura subrbol izquierdo.

Balance = 0implica que las alturas de los dos subrboles son iguales.

Balance = -1implica que la altura subrbol izquierdo es mayor que altura subrbol derecho.


4/27


- 3 -

Almacenar el valor de "Balance" en la estructura interna de cada nodo permite establecer en qusituacin despus de agregar o extraer un nodo se debe o no realizar la "reorganizacin" del rbol.

Rotaciones

El siguiente esquema muestra un caso sencillo en el que se consideran el nodo "P" y el nodo "Q"

que se encuentra a la derecha del nodo "P" ; en el esquema el balance de "Q" es 0 y el balance de"P" es 1, dado que los tres subrboles tiene una altura cuyo valor se representa como "h".

Se agrega un nodo en el subrbol derecho de "Q" cambiando la altura del mismo de manera quedespus de agregar el nodo los balances (si se calcularan) quedaran para el nodo "Q" en 1 y parael nodo "P" en 2 lo que no puede ser debiendo realizarse una reorganizacin del rbol.

La solucin es lograr que el nodo "Q" sea padre del nodo "P" sin perder el subrbol izquierdo delnodo "Q" que obviamente por el criterio de orden pasa a ser subrbol derecho de "P".

Antes Despus Solucin

Esta reorganizacin se conoce como Rotacin Simple Derecha - Derecha.

En el siguiente esquema se muestra otra posibilidad, en este caso se agrega un nodo que cambiala altura en el subrbol izquierdo de "Q", que recordemos se encuentra en el subrbol derecho de"P", particularmente se analiza el caso en que el nuevo nodo se agrega en el subrbol derecho delnodo "R" que segn el esquema se encuentra a la izquierda del nodo "Q". El mismo anlisis sepuede hacer para el subrbol izquierdo de "R"

AntesDespus

Alternativa


5/27


- 4 -

Se observa que los balances (si se calcularan) en este caso resultaran balance de "Q" -1 y balancede "P" 2, lo que no puede ser debiendo realizarse una reorganizacin del rbol.

La solucin es lograr que el nodo "R" sea padre de los nodos "P" y "Q" sin perder los subrbolesizquierdo y derecho del nodo "R" que por el criterio de orden el subrbol izquierdo de "R" pasa aser subrbol derecho de "P" y el subrbol derecho de "R" pasa a ser subrbol izquierdo de "Q".

Solucin 1er paso Solucin 2do paso

Esta reorganizacin se conoce como Rotacin Doble Derecha - Izquierda.

Es importante destacar que despus de agregar el nodo en cualquiera de los casos no se calculanlos balances, se utiliza una tcnica recursiva para agregar el nodo y al retroceder en la recursinuna variable lgica pasada por referencia indica si la altura ha cambiado en cuyo caso cuando laagregacin del nodo se produjo por una secuencia de balances 1 y 0 (como en los esquemas) escuando se debe realizar la rotacin, si la agregacin se hizo por la derecha es una rotacin simple ysi se hizo por la izquierda es una rotacin doble.

Se remarca la situacin en que la secuencia de balances 1 y 0 es la que indica cuando puede hacerfalta reorganizar el rbol, dado que al agregar por la derecha en esa secuencia de balances es laque corresponde a la deduccin realizada. El valor de balance 1 indica que la altura del subrbolderecho es mayor que la altura del subrbol izquierdo y el valor de balance 0 del nodo raz delsubrbol derecho indica que las alturas de sus subrboles estn equilibradas, agregar un nodo enalguno de esos subrboles puede requerir de una rotacin lo que se descubre cuando cambia laaltura esta situacin se conoce por la variable lgica que se pasa por referencia en el procesorecursivo.

El mismo anlisis se puede realizar para el caso en que se agregue un nodo por el subrbolizquierdo. En este caso la secuencia de balances que debe tenerse en cuenta es -1 y 0, dado que elvalor de balance -1 indica que la altura del subrbol izquierdo es mayor que la altura del subrbol

derecho y el balance 0 del nodo raz del subrbol izquierdo indica que las alturas de sus subrbolesestn equilibradas; agregar un nodo por la izquierda de esta secuencia puede implicar unarotacin, que nuevamente se descubre cuando cambia la altura lo que se indica con una variablelgica utilizada en el proceso recursivo. Las rotaciones resultantes se conocen como RotacinSimple Izquierda - Izquierday Rotacin Doble Izquierda - Derecha.

En ambos caso rotacin simple o doble, el nodo "P" es un nodo cualquiera, an cuando en elesquema aparece como raz del rbol, puede existir un nodo "padre" de P y todo un rbol porencima de este nodo. La cuestin es que la reorganizacin del rbol solamente se realiza desde el


6/27


- 5 -

nodo que se agrega hasta el nodo "P" que se reemplaza por el nodo "Q" si la rotacin es simple oel nodo "R" si la rotacin es doble, observen que en ambos casos la altura del subrbol a partir delnodo "P" y la altura del subrbol resultante despus de aplicar la rotacin es la misma,consecuentemente el balance de un supuesto nodo "padre" del nodo "P" no se ve afectada.

En el caso de una extraccin de un elemento del rbol, se aplican todas las consideraciones de los

rboles binarios de bsqueda; si el elemento a extraer est en un nodo hoja simplemente sedesconecta el nodo, en caso que el elemento se encuentre en un nodo con un descendiente seconecta el nodo padre con el subrbol descendiente y en el caso que el elemento se encuentre enun nodo con dos subrboles debe aplicarse alguna de las tcnicas mayor de los menores o menorde los mayores adems de decidir realizar la extraccin por fusin o copia. Pero en el caso derboles equilibrado (particularmente los rboles AVL) adems de todo esto se debe considerar quesi se extrae un elemento (suprime un nodo) de un subrbol cuya altura es menor que la altura delsubrbol "hermano", si la altura cambia hacer falta reorganizar el rbol.

Deducciones semejantes a las realizadas para el caso de la agregacin de elementos son aplicablesen el caso de extraccin de elementos, se debe destacar que a diferencia de la agregacin que solorequiere rotaciones hasta el nodo que se identifica como "P" (nodo cuyo balance es 1 o -1), en el

caso de las extracciones las rotaciones pueden avanzar desde el subrbol que contiene alelemento a extraer hasta la raz misma del rbol de modo que puede consumir ms tiempo que laagregacin.

En los rboles AVL la agregacin o eliminacin de un elemento puede requerir como mximo1.44 lg(n+2) bsquedas, adems la agregacin puede requerir una rotacin simple o doble, y laextraccin puede requerir 1.44 lg(n+2) rotaciones en el peor caso. Sin embargo los casos empricosmuestran que el caso promedio requiere lg(n) + .25 bsquedas, en el 78% de los casos lasextracciones no requieren rotaciones y el 53% de las agregaciones no requieren rotaciones.Consecuentemente los rboles AVL son ampliamente utilizados en la industria incluso sedesarrollan implementaciones que extienden el criterio de balance, permitiendo diferencias dealtura de 2 o 3 en valor absoluto, duplicando la cantidad de bsquedas necesarias pero

disminuyendo la cantidad de reestructuraciones en un factor de 10

Ejercicio grfico

En este ejercicio, la secuencia de elementos 14, 6, 24, 35, 59, 17, 21, 32, 4, 7, 15, 22 seagregar en rbol AVL inicialmente vaco.

Los cuatro primeros elementos se agregan de manera normal, buscando su posicin yenlazando el nodo que contiene al elemento en cuestin.

{ 14 }

{ 14(6) } { 14(6,24) }

{ 14(6,24(,35) }


7/27


- 6 -

Al agregar el elemento cuyo valor es 59, se observa que se hace por la derecha de una secuenciade balances 1 y 0, se aplica la Rotacin Simple Derecha - Derecha.

NO es AVL

{ 14(6,35(24,59)) }

Al agregar el elemento cuyo valor es 17, se observa que se hace por la derecha de una secuenciade balances 1 y 0, y en este caso se vez se aplica una la Rotacin Doble Derecha - Izquierda.

NO es AVL{ 24(14(6,17),35(,59)) }

Los siguientes elementos se agregan de manera normal

{ 24(14(6,17(,21)),35(,59)) } { 24(14(6,17(,21)),35(32,59)) }


8/27


- 7 -

En los siguientes esquemas se muestra una situacin particular, en la que despus de agregar el

nodo cuyo valor es 4, se debe agregar el nodo con valor 7y luego el de valor 15. En los dos ltimoscasos (7 y 15) se observa que se realiza una agregacin sobre una secuencia -1 y 0 quecorresponde a los nodos 24 y 14 respectivamente, la agregacin se realiza por la izquierda dedicha secuencia de modo que podra pensarse que hay que realizar alguna rotacin, sin embargodebe observarse que en ambos casos la altura no cambia del subrbol en el que se agrega el nodono cambia, de manera que no se realiza rotacin alguna.

{ 24(14(6(4),17(,21),35(32,59)) }

{ 24(14(6(4,7),17(,21),35(32,59)) }

{ 24(14(6(4,7),17(15,21),35(32,59)) }

El ltimo valor que se agrega es el 22, que se agrega en una secuencia -1 y 0, cambiando la alturadel subrbol de modo que debe aplicarse una rotacin y en este caso corresponde la RotacinDoble Izquierda - Derecha.

NO es AVL { 17(14(6(4,7),15),24(21(,22),35(32,59))) }Es importante destacar que el nodo cuyo balance es 1 o -1 es el que se identifica con la referencia"n", y corresponde al nodo "P" de la elaboracin terica, mientras que el nodo cuyo balance es 0(sea el del subrbol izquierdo o derecho) se identifica con la referencia "n1" y es el quecorresponde al nodo "Q" en la elaboracin terica, el nuevo nodo se puede agregarinmediatamente despus del nodo "Q" o ms abajo en el subrbol pero la rotacin (simple o doblese realiza sobre los nodos "P", "Q" "R" si hace falta lo que se identifica con las referencias "n", "n1"y "n2" en cada caso.


9/27


- 8 -

Implementacin de un rbol AVL

Como en el caso de los rboles binarios de bsqueda, en este caso tambin hace falta uncomponente que permita almacenar la informacin del elemento en el rbol y adems mantengalas referencias a los subrboles izquierdo y derecho; adems este componente debe contar con uncampo y propiedad que mantenga el balance del nodo. Obviamente se trata de objeto del tipo

nodo que en este caso se muestra a continuacin.

Cdigo de NodeAVL

usingSystem;

namespaceDemoArbol6{//////Clase para representar un nodo de un rbol binario//////Tipo de dato del elemento

publicclassNodeAVL{

#regionEstructura Interna//////Mantiene el elemento en el nodo///privateELEMENT _Item;//////Mantiene el enlace al subrbol izquierdo///privateNodeAVL _Left;//////Mantiene el elace al subrbol derecho

///privateNodeAVL _Right;//////Mantiene el factor de equilibrio del nodo///privateint_Balance;

#endregion

#regionPropiedades Getters and Setters//////Facililta el acceso al elemento en el nodo///

publicELEMENT Item{get{ returnthis._Item; }set{ this._Item = value; }

}//////Facilita el acceso al enlace al subrbol izquierdo///publicNodeAVL Left{


10/27


- 9 -

get{ returnthis._Left; }set{ this._Left = value; }

}//////Facilita el acceso al enlace al subrbol derecho///publicNodeAVL Right{get{ returnthis._Right; }set{ this._Right = value; }

}//////Facilita el acceso al factor de equilibrio del nodo///publicintBalance{get{ return_Balance; }set{ _Balance = value; }

}#endregion

#regionConstructores//////Constructor por defecto, inicializa los campos de la estructura///interna en valores por defecto///publicNodeAVL(){this.Item = default(ELEMENT);this.Left = null;this.Right = null;this.Balance = 0;

}//////Constructor especializado, permite fijar el elemento del nodo//////Elemento en el nodopublicNodeAVL(ELEMENT item): this()

{this.Item = item;

}//////Constructor especializado, permite fijar el elemento del nodo///y el valor de los enlaces a subrboles izquierdo y derecho//////Elemento en el nodo

///Enlace al subrbol izquierdo///Enlace al subrbol derechopublicNodeAVL(ELEMENT item, NodeAVL left, NodeAVL

right): this()

{this.Item = item;this.Left = left;this.Right = right;

}


11/27


- 10 -

#endregion

//////Metodo para probar las distintas formas en que///se puede recorrer un rbol///publicvoidVisit(){Console.Write("{0} ", this.Item.ToString());

}}

}

Cdigo de BalancedTree

La siguiente es una implementacin bastante completa de un rbol binario de bsquedabalanceado.

Se implementa el comportamiento para recorrer el rbol en orden, en pre orden y en post orden,de este modo se puede verificar que la implementacin mantiene el orden previsto en la interfaceIComparable. Para ello se codific un mtodo "Visit()" en el nodo; esto no es lo ms adecuado,debera implementarse un mecanismo con "delegates" pero eso est fuera del alcance de lamateria, deben verlo en Programacin Orientada a Objetos.

Tambin se implement el comportamiento para determinar si un elemento est o no en el rbolContains( ... ), as como un mtodo que busca el nodo que contiene un elemento en particularFind( ... ) que devuelve una referencia al nodo o null en caso que no exista.

Como siempre, se organiz el cdigo en regiones de manera que sea sencillo hallar la porcin decdigo que implementa cierto comportamiento.

usingSystem;

namespaceDemoArbol6{//////Implementacin de rbol binario//////Tipo de dato de elementos que se

introduce en el rbolpublicclassBalancedTree whereELEMENT : IComparable{

#regionEstructura interna

//////Mantiene la raz del rbol///privateNodeAVL _Root;#endregion

#regionPropiedades//////Facililta el acceso a la raz del rbol///


12/27


- 11 -

protectedvirtualNodeAVL Root{get{ returnthis._Root; }set{ this._Root = value; }

}//////Indica si el rbol est vacio///publicvirtualBooleanIsEmpty{get{ returnthis.Root == null; }

}#endregion

#regionConstructores//////Constructor por defecto///publicBalancedTree(){

this.Root = null;}//////Constructor especializado, permite asignar///el valor del item de la raz del rbol//////referencia al item de la raz del rbol, puede

ser nullpublicBalancedTree(ELEMENT item): this()

{this.Root = newNodeAVL(item);

}//////Constructor especializado, permite asignar///el valor del item de la raz del rbol y///los subrboles izquierdo y derecho//////referencia al item de la raz del rbol, puede

ser null///referencia a un rbol que estar a la

izquierda, puede ser null///referencia a un rbol que estar a la

derecha, puede ser nullpublicBalancedTree(ELEMENT item, BalancedTree leftTree,

BalancedTree rightTree): this()

{this.Root = newNodeAVL(item);if(leftTree != null){this.Root.Left = leftTree.Root;

}if(rightTree != null){this.Root.Right = rightTree.Root;

}


13/27


- 12 -

}#endregion

#regionComportamiento heredado de object//////Muestra la representacin del rbol en forma de lista//////Cadena con la representacinpublicoverridestringToString(){returnToString(this.Root);

}//////Implementacin recursiva para mostrar un rbol en forma de lista//////Nodo del rbol///Cadena con la representacinprotectedvirtualstringToString(NodeAVL root){strings = string.Empty;

if(root != null){s = root.Item.ToString();if(root.Left != null){s = s + " ("+ ToString(root.Left);if(root.Right != null){s = s + ", "+ ToString(root.Right);

}s = s + ")";

}else{if(root.Right != null){s = s + " (, "+ ToString(root.Right) + ")";

}}

}returns;

}#endregion

#regionComportamiento para recorrer un rbol//////Implementacin del recorrido Pre Orden

///para la instancia///publicvirtualvoidPreOrder(){PreOrder(this.Root);

}//////Implementacin recursiva para recorrer un///rbol en Pre Orden///


14/27


- 13 -

///Nodo a visitarprotectedvirtualvoidPreOrder(NodeAVL root){if(root != null){root.Visit();PreOrder(root.Left);PreOrder(root.Right);

}}//////Implementacin del recorrido En Orden///para la instancia///publicvirtualvoidInOrder(){InOrder(this.Root);

}//////Implementacin recursiva para recorrer un

///rbol en En Orden//////Nodo a visitarprotectedvirtualvoidInOrder(NodeAVL root){if(root != null){InOrder(root.Left);root.Visit();InOrder(root.Right);

}}//////Implementacin del recorrido Post Orden///para la instancia///publicvirtualvoidPostOrder(){PostOrder(this.Root);

}//////Implementacin recursiva para recorrer un///rbol en PostOrden//////Nodo a visitarprotectedvirtualvoidPostOrder(NodeAVL root){

if(root != null){PostOrder(root.Left);PostOrder(root.Right);root.Visit();

}}#endregion

#regionBsqueda de un elemento


15/27


- 14 -

//////Determina si un elemento est contenido en el rbol//////Elemento a controlar///Verdadero si el elemento se encuentra contenido en el

rbolpublicvirtualBooleanContains(ELEMENT item){returnContains(this.Root, item);

}//////Implementacin recursivoa para determinar si un elemento///se encuentra contenido en el rbol//////Nodo raz del subrbol a considerar///Elemento a controlar///Verdadero si el elemento se encuentra contenido en el

rbolprotectedvirtualBooleanContains(NodeAVL root, ELEMENT

item)

{if(root == null){returnfalse;

}if(item.CompareTo(root.Item) < 0){returnContains(root.Left, item);

}else{if(item.CompareTo(root.Item) > 0){returnContains(root.Right, item);

}}returntrue;

}//////Busca un elemento en el rbol//////Elemento a buscar///Referencia al elemento o null si no est en el

rbolpublicvirtualELEMENT Find(ELEMENT item){returnFind(this.Root, item);

}//////Implementacin recursiva para buscar un elemento en el rbol//////Nodo raz del subrbol a considerar///Elemento a buscar///Referencia al elemento o null si no est en el

rbolprotectedvirtualELEMENT Find(NodeAVL root, ELEMENT item){


16/27


- 15 -

if(root == null){returndefault(ELEMENT);

}if(item.CompareTo(root.Item) < 0){returnFind(root.Left, item);

}else{if(item.CompareTo(root.Item) > 0){returnFind(root.Right, item);

}}returnroot.Item;

}#endregion

#regionAgregar un elemento

//////Agrega un elemento en el rbol equilibrado//////Elemento a agregarpublicvirtualvoidAdd(ELEMENT item){boolflag = false;this.Root = AddAVL(this.Root, item, refflag);

}//////Implementacin recursiva para agregar un elemento en un///rbol equilibrado utilizando los conceptos de A V L//////Nodo raiz del subrbol a considerar///Elemento a agregar///Bandera que indica que cambi la

altura///Nodo raiz del subrbol consideradoprotectedvirtualNodeAVL AddAVL(NodeAVL root,

ELEMENT item, refboolflag){NodeAVL n1;// Si el rbol est vacio, simplement se agrega// y se indica que cambi la alturaif(root == null){root = newNodeAVL(item);

flag = true;}else{if(item.CompareTo(root.Item) < 0){// El valor del elemento a agregar es menor// que el valor de la raz del subrbol// Se agrega recursivamente por la izquierdaroot.Left = AddAVL(root.Left, item, refflag);


17/27


- 16 -

if(flag) // cambi la altura ?{switch(root.Balance){case1:// antes derecha > izquierda, despus se equilibra// y cambia la banderaroot.Balance = 0;flag = false;break;

case0:// anstes derecha = izquierda, despus izquierda mas

grande// en algn nivel superior puede hacer falta un

rebalanceo// la bandera queda como estaba (true)root.Balance = -1;break;

case-1:// antes derecha < izquierda, hay que rebalancear

n1 = root.Left;if(n1.Balance == -1){// la izquierda de la izquierda es mayor// rotacin simple izquierda-izquierdaroot = LeftLeftRotation(root, n1);

}else{// rotacin doble izquierda-derecharoot = LeftRightRotation(root, n1);

}// subrbol ajustado cambia la banderaflag = false;break;

}}

}else{if(item.CompareTo(root.Item) > 0){// El valor del elemento a agregar es mayor// que el valor de la raz del subrbol// Se agrega recursivamente por la derecharoot.Right = AddAVL(root.Right, item, refflag);if(flag) // cambi la altura ?

{switch(root.Balance){case1:// antes derecha > izquierda, hay que rebalancern1 = root.Right;if(n1.Balance == 1){// la derecha de la derecha es mayor// rotacin simple derecha-derecha


18/27


- 17 -

root = RightRightRotation(root, n1);}else{// rotacin doble derecha-izquierdaroot = RightLeftRoation(root, n1);

}// subrbol ajustado cambia la banderaflag = false;break;

case0:// antes derecha = izquierda, despus la derecha mas

grande// en algn nivel superior puede hacer falta un

rebalanceo// la bandera queda como estaba (true)root.Balance = 1;break;

case-1:// antes derecha < izquierda, despues se equilibra

// y cambia la banderaroot.Balance = 0;flag = false;break;

}}

}else{// No se puede almacenar claves repetidasthrownewException("Claves repetidas");

}}

}returnroot;

}

#endregion

#regionExtraer un elemento//////Extrae un elemento en el rbol equilibrado//////Elemento a extraerpublicvirtualvoidRemove(ELEMENT item){boolflag = false;

this.Root = RemoveAVL(this.Root, item, refflag);}//////Implementacin recursiva para extraer un elemento en un///rbol equilibrado utilizando los conceptos de A V L//////Nodo raiz del subrbol a considerar///Elemento a extraer///Bandera que indica que cambi la

altura


19/27


- 18 -

///Nodo raiz del subrbol consideradoprotectedvirtualNodeAVL RemoveAVL(NodeAVL root,

ELEMENT item, refboolflag){// No se puede extraer nodos de un rbol vacoif(root == null){thrownewException("No existe");

}if(item.CompareTo(root.Item) < 0){// El valor del elemento a extraer es menor// que el valor de la raz del subrbol// Se procesa recursivamente por la izquierdaroot.Left = RemoveAVL(root.Left, item, refflag);if(flag){// Cambi la altura, analizar el balanceroot = LeftBalance(root, refflag);

}

}else{if(item.CompareTo(root.Item) > 0){// El valor del elemento a extraer es mayor// que el valor de la raz del subrbol// Se procesa recursivamente por la derecharoot.Right = RemoveAVL(root.Right, item, refflag);if(flag){// Cambi la altura, analizar el balanceroot = RightBalance(root, refflag);

}}else{ // encontradoNodeAVL q;q = root;if(q.Left == null){// Un nico descendiente, cambia la alturaroot = q.Right;flag = true;

}else{

if(q.Right == null){// Un nico descendiente, cambia la alturaroot = q.Left;flag = true;

}else{ // tiene dos subrboles !!!root.Left = Repleace(root, root.Left, refflag);if(flag)


20/27


- 19 -

{// Cambi la altura, analizar el balanceroot = LeftBalance(root, refflag);

}q = null;

}}

}}returnroot;

}#endregion

#regionUtilitarios para extraer un elemento//////Aplica mayor de los menores controlando el cambio de altura///La tcnica aplicada es eliminacin por copia con bsqueda

recursiva//////Nodo que debe extraerse

///Nodo que corresponde al mayor de losmenores

///Bandera que indica que cambi laaltura

///protectedvirtualNodeAVL Repleace(NodeAVL n,

NodeAVL act, refboolflag){if(act.Right != null){// hay algo a la derecha, es mayor que el actualact.Right = Repleace(n, act.Right, refflag);if(flag){// Cambi la altura, analizar el balanceact = RightBalance(act, refflag);

}}else{// act es el mayor de los menores// copiar el elemento y anular la referencia// cambia la alturan.Item = act.Item;n = act;act = act.Left;n = null;

flag = true;}returnact;

}//////Analiza las posibles rotaciones cuando se extrajo un nodo de la

izquierda//////Nodo a considerar


21/27


- 20 -

///Bandera que indica que cambi laaltura

///Nodo consideradoprotectedvirtualNodeAVL LeftBalance(NodeAVL n,

refboolflag){NodeAVL n1;switch(n.Balance){case-1:// antes izquierda > derecha, despus se equilibran.Balance = 0;break;

case0:// antes izquierda = derecha, despues se ajusta// y cambia la alturan.Balance = 1;flag = false;break;

case1:

// antes izquierda < derecha, hay que rebalancer// situaciones especiales para el cambio de alturan1 = n.Right;if(n1.Balance >= 0){flag = false;n = RightRightRotation(n, n1);

}else{n = RightLeftRoation(n, n1);

}break;

}returnn;

}//////Analiza las posibles rotaciones cuando se extrajo un nodo de la

derecha//////Nodo a considerar///Bandera que indica que cambi la

altura///Nodo consideradoprotectedvirtualNodeAVL RightBalance(NodeAVL n,

refboolflag){

NodeAVL n1;switch(n.Balance){case-1:// antes izquierda > derecha, hay que rebalancer// situaciones especiales para el cambio de alturan1 = n.Left;if(n1.Balance


22/27


- 21 -

{flag = false;

}n = LeftLeftRotation(n, n1);

}else{n = LeftRightRotation(n, n1);

}break;

case0:// antes izquierda = derecha, despus se ajusta// y cambia la alturan.Balance = -1;flag = false;break;

case1:// antes izquierda < derecha, despus se equilibran.Balance = 0;break;

}returnn;

}#endregion

#regionRotaciones//////Rotacion simple Izquierda - Izquierda//////Nodo raz a considerar///Nodo a la izquierda del raz a

considerar///Nuevo nodo razprotectedvirtualNodeAVL LeftLeftRotation(NodeAVL

n, NodeAVL n1){n.Left = n1.Right;n1.Right = n;if(n1.Balance == -1){n.Balance = 0;n1.Balance = 0;

}else{n.Balance = -1;n1.Balance = 1;

}returnn1;

}//////Rotacion doble Izquierda - Derecha//////Nodo raz a considerar///Nodo a la izquierda del raz a

considerar///Nuevo nodo raz


23/27


- 22 -

protectedvirtualNodeAVL LeftRightRotation(NodeAVLn, NodeAVL n1)

{// Nodo a la derecha del nodo que est a la izquierda del nodo raz

a considerarNodeAVL n2;n2 = n1.Right;n.Left = n2.Right;n2.Right = n;n1.Right = n2.Left;n2.Left = n1;n1.Balance = (n2.Balance == 1) ? -1 : 0;n.Balance = (n2.Balance == -1) ? 1 : 0;n2.Balance = 0;returnn2;

}//////Rotacion simple Derecha - Derecha//////Nodo raz a considerar

///Nodo a la derecha del raz a considerar///Nuevo nodo razprotectedvirtualNodeAVL

RightRightRotation(NodeAVL n, NodeAVL n1){n.Right = n1.Left;n1.Left = n;if(n1.Balance == 1){n.Balance = 0;n1.Balance = 0;

}else{n.Balance = 1;n1.Balance = -1;

}returnn1;

}//////Rotacion doble Derecha - Izquierda//////Nodo raz a considerar///Nodo a la derecha del raz a considerar///Nuevo nodo razprotectedvirtualNodeAVL RightLeftRoation(NodeAVL

n, NodeAVL n1)

{// Nodo a la izquierda del nodo que est a la derecha del nodo raz

a considerarNodeAVL n2;n2 = n1.Left;n.Right = n2.Left;n2.Left = n;n1.Left = n2.Right;n2.Right = n1;n.Balance = (n2.Balance == 1) ? -1 : 0;


24/27


- 23 -

n1.Balance = (n2.Balance == -1) ? 1 : 0;n2.Balance = 0;returnn2;

}#endregion

}}

Cdigo para probar un BalancedTree

usingSystem;

namespaceDemoArbol6{classProgram{staticvoidMain(string[] args){// 14, 6, 24, 35, 59, 17, 21, 32, 4, 7, 15, 22

BalancedTree a = newBalancedTree();

Console.WriteLine("Agregaciones");a.Add(14); a.InOrder(); Console.WriteLine(" -> {0}", a.ToString());a.Add(6); a.InOrder(); Console.WriteLine(" -> {0}", a.ToString());a.Add(24); a.InOrder(); Console.WriteLine(" -> {0}", a.ToString());a.Add(35); a.InOrder(); Console.WriteLine(" -> {0}", a.ToString());a.Add(59); a.InOrder(); Console.WriteLine(" -> {0}", a.ToString());

;a.Add(17); a.InOrder(); Console.WriteLine(" -> {0}", a.ToString());a.Add(21); a.InOrder(); Console.WriteLine(" -> {0}", a.ToString());a.Add(32); a.InOrder(); Console.WriteLine(" -> {0}", a.ToString());a.Add(4); a.InOrder(); Console.WriteLine(" -> {0}", a.ToString());a.Add(7); a.InOrder(); Console.WriteLine(" -> {0}", a.ToString());a.Add(15); a.InOrder(); Console.WriteLine(" -> {0}", a.ToString());a.Add(22); a.InOrder(); Console.WriteLine(" -> {0}", a.ToString());

Console.WriteLine("Extracciones");a.Remove(6); a.InOrder(); Console.WriteLine(" -> {0}",

a.ToString());a.Remove(7); a.InOrder(); Console.WriteLine(" -> {0}",





a.ToString());

Console.WriteLine("Esta el 35 {0}", a.Contains(35));Console.WriteLine("Esta el 99 {0}", a.Contains(99));

}}

}


25/27


- 24 -

La salida del programa es la siguiente:

Ejercicio

El siguiente ejemplo muestra cmo se puede utilizar un rbol binario de bsqueda balanceadopara contar cuantas veces aparece cada palabra en un texto dado, por supuesto que se puederealizar el ejercicio de diferentes maneras pero la idea es utilizar un rbol AVL, de modo quevamos a implementar un objeto que permita almacenar una palabra y un contador que seincremente cada vez que esa palabra aparece en el texto.

Clase PalabraComo se pretende utilizar los objetos del tipo Palabra en un rbol balanceado, esta clase debeimplementar la interface IComparable.

usingSystem;

namespaceDemoArbol6{publicclassPalabra: IComparable{//////Mantiene la palabra misma

///privateStringcadena;//////Mantiene una cuenta de la cantidad de veces///que la palabra aparece en el texto///privateintcuenta;//////Constructor por defecto///


26/27


- 25 -

publicPalabra(){cadena = String.Empty;cuenta = 0;

}//////Constructor especializado//////Valor de la palabrapublicPalabra(stringword){this.cadena = word;this.cuenta = 1;

}//////Incrementa en uno el contador de ocurrencias///de la palabra//////Cantidad de ocurrencias de la palabrapublicintIncrementa()

{return(++this.cuenta);

}

#regionIComparable Members//////Implementacin de la interface IComparable//////Objeto con el que se compara el actual///Entero menor a cero si el objeto actual es menor, mayor

a cero si el objeto actual es mayor y igual a cero si soniguales

intIComparable.CompareTo(objectobj){if((obj != null) && (obj isPalabra)){returnthis.cadena.CompareTo(((Palabra)obj).cadena);

}thrownewNotImplementedException();

}#endregion

//////Implementacin para entregar una representacin del objeto actual//////Cadena con la representacin del objeto actualpublicoverridestringToString()

{returnString.Format("{0} {1}", this.cadena,

this.cuenta.ToString());}

}}

Obsrvese que la implementacin de CompareTo verifica que el objeto sea vlido y que sea deltipo correcto, para recin proceder a realizar una comparacin entre cadenas.


27/27


- 26 -

Mtodo para contar palabras

El siguiente cdigo se utiliza para contar las veces que cada palabra aparece en un texto, en elejemplo el texto se obtiene de un archivo (planto o txt) cuyo nombre (incluso la ruta de acceso) sepasan como parmetro.

El mtodo lee archivo completo en memoria, luego genera un arreglo de palabras de acuerdo adistintos separadores (mtodo Split de la clase String), luego declara e instancia un rbolbalanceado y para cada una de las palabras del texto verifica si existen en el rbol incrementa elcontador caso contrario agrega la palabra.

Finalmente muestra en orden los elementos del rbol y la estructura del mismo.

staticvoidCuentaPalabras(StringfileName){if(!System.IO.File.Exists(fileName)){thrownewException("No existe el archivo "+ fileName);

}

StringfileData = System.IO.File.ReadAllText(fileName,System.Text.Encoding.Default);

String[] words = fileData.Split(" ,.\n\r".ToCharArray());BalancedTree a = newBalancedTree();Palabratemp, find;foreach(Stringword inwords){if(!String.IsNullOrEmpty(word)){temp = newPalabra(word.ToUpper());if((find = a.Find(temp)) != null){find.Incrementa();

}else{a.Add(temp);

}}

}Console.WriteLine("Arbol en orden:");a.InOrder();Console.WriteLine("\n\nArbol (estructura):\n{0}", a.ToString());

}

ConclusinLas implementaciones de rboles binarios de bsqueda y rboles balanceados no son simples perotampoco demasiado complejas, la lgica que realiza el comportamiento esperado ya estdesarrollada y probada. En el framework de los lenguajes de programacin orientados a objetosno suele encontrarse clases que implementen rboles esto es as porque en general el tratamientode grandes cantidades de informacin se realiza con motores de base de datos en cuyo cdigo sise encuentra este tipo de implementaciones.

estructura de datos y arboles equilibrados

Documents