Comparacin Tcnicas y Algoritmos de Balanceo

Comparacin Tcnicas y Algoritmos de Balanceo

Lady Lorena Hernndez Sandoval, John Elkin Jimnez Lpez, Bayron Daniel Mendoza Tovar
Universidad Pedaggica y Tecnolgica de Colombia
Ingeniera de Sistemas y Computacin
lady.hernandez01@uptc.edu.co
john.jimenez02@uptc.edu.co
bayron.mendoza@uptc.edu.co

Resumen: En este artculo se tendr en cuenta, el
concepto de balanceo al que se le dar una posible
solucin a travs diferentes tipos de algoritmos
planteados, tanto en el rbol AA Tree como en el Heap,
generan importancia al momento de resolver problemas,
como el ordenamiento de sus elementos, para mejorar
su diseo y hacer funcional su implementacin
debidamente.
Palabras claves: Heap, ordenar, rbol binario,
balancear, AA Tree.
Abstract: This article will take into account the
concept of balancing will be that a possible solution
through different types of algorithms posed, both the
AA Tree tree and Heap, generate importance when
solve problems, such as the ordering of its elements to
improve your design and make functional
implementation properly.
key words: Heap, order, binary tree, swing, AA
Tree.
INTRODUCCIN
Es importante observar que la estructura de rboles
es fundamental en la computacin. Su importancia
radica en la capacidad que tiene para el manejo de
informacin de manera dinmica, es decir dando la
posibilidad de la fcil realizacin de cambios en la
informacin a lo largo del tiempo.
El concepto de balanceo se da a conocer como una
solucin al crecimiento y altura de estos, las tcnicas de
balanceo son importantes ya que se cuentan con
diversos algoritmos que requieren de esta tcnica para
la mejora de su implementacin y uso de datos.
En este trabajo se revisar el concepto de balanceo
en diversos tipos de algoritmos en los que se ejecutara
eficientemente operaciones que permiten el
mejoramiento del algoritmo.
En el caso de balanceo tenemos como ejemplo un
montculo que es un rbol binario balanceado en el cual
est diseado para resolver el problema elementos
dentro de un vector.
AA TREE
Es un tipo de rbol binario de bsqueda y auto-
balanceable, es decir, intenta mantener su altura o su
nmero de nodos bajo la raz, tan pequea como sea
posible en todo momento, automticamente, utilizado
para almacenar y recuperar informacin ordenada de
manera eficiente. Estos rboles son una variacin del
rbol rojo-negro y es una mejora del rbol binario de
bsqueda.
Se debe cumplir el estricto requisito de que solo los
enlaces derechos pueden ser rojos y a diferencia de los
rboles rojo-negro, estos se implementan con la idea de
nivel y no de color.
Comparacin Tcnicas y Algoritmos de Balanceo

Para mantener el equilibrio de este se necesitan dos

operaciones llamadas torsin (skew) y divisin (split).
Algunas funciones
Sirven para almacenar y recuperar informacin
ordenada de manera eficiente. En el mbito
computacional se utiliza para organizar informacin [1]
Divisin (Split): La divisin es una rotacin
compuesta por datos comparables.
izquierda condicional que tiene lugar cuando una
Caractersticas
insercin o un borrado crea dos enlaces horizontales
- Las condiciones para que el rbol sea vlido son las
derechos, lo que de nuevo se corresponde con dos
siguientes:
enlaces rojos consecutivos en el contexto de los rboles
1. El nivel de un hijo izquierdo debe ser menor que
rojo-negro.
el nivel de su padre.
2. El nivel de un hijo derecho debe ser menor o igual
al nivel de su padre.
3. El nivel de un nieto derecho debe ser menor que
el nivel de su abuelo.
4. El nivel de un nodo hoja es 1.
5. Cada nodo de nivel superior a uno debe tener dos
hijos. [2]
- Los nodos tienen nivel y no color. Bsqueda
Algoritmos de balanceo Para hacer la bsqueda con rboles AA, se puede
El rbol AA es una variacin de rbol rojo-negro, hacer de la siguiente manera: primero, se empieza con
que a su vez es una mejora de rbol binario de bsqueda. la raz.
A diferencia de los arboles rojo-negro, los nodos rojos Si la raz es igual al nmero que se busca, entonces
en un rbol AA solo pueden aadirse como un hijo retorna verdadero.
derecho. Si no es igual, entonces compara si el nmero es
En un rbol AA, al cumplirse el requisito de un solo mayor o menor a la raz.
los enlaces derechos pueden ser rojos, solo es necesario Si es menor, entonces va hacia el nodo hijo
considerar dos formas de balanceo: izquierdo.
Torsin (Skew): La torsin es una rotacin derecha Si es mayor a la raz entonces va hacia el nodo hijo
que se realiza cuando una insercin o un borrado genera derecho. Se hace el mismo procedimiento solo que con
un enlace horizontal izquierdo, puede pensarse como un el nodo hijo hasta llegar hasta una hoja.
enlace rojo izquierdo en el contexto del rbol rojo- Si la hoja no es igual al nmero que se busca,
negro. entonces retorna falso.
Comparacin Tcnicas y Algoritmos de Balanceo

Insercin Eliminar un nodo con un hijo: en este caso, se

Todos los nodos inicialmente se insertan como reemplaza el nodo a eliminar con su hijo. Por ser un
nodos hoja utilizando el estndar del rbol de bsqueda rbol AA, un hijo nico siempre ser derecho.
binaria. Eliminar un nodo interno: cuando el nodo a
- Enlaces horizontales en los rboles AA: eliminar tiene 2 hijos, este se sustituye por el sucesor o
Las cinco condiciones de rboles AA imponen antecesor inmediato.
restricciones a los enlaces horizontales.
Si alguna de las condiciones se violan el rbol debe
ser modificado hasta que, una vez ms cumple con las
cinco condiciones.
Slo dos casos deben ser considerados y corregidos
para mantener el equilibrio de un rbol AA.
Caso No. 1: Enlace horizontal izquierda no se les
permite: Violar la condicin No. 2, el nivel de un hijo
izquierdo es estrictamente menor que la de su padre.
Una operacin de sesgo o inclinacin se introdujo para
manejar este caso
Caso No. 2: Dos enlaces horizontales correctas
consecutivas no se les permite: Violar la condicin No.
4, el nivel de un nieto derecha es estrictamente menor
que el de su abuelo. Una operacin de divisin ser
introducida para manejar este caso.

[3]
Eliminar
A la hora de eliminar un nodo pueden presentarse 3
casos:
[4]
Eliminar una hoja: para eliminar una hoja (nodo sin
hijos), basta con borrarla.
Comparacin Tcnicas y Algoritmos de Balanceo
Rebalanceo
Luego de eliminar un nodo, puede ser necesario re
balancear el rbol.
Para esto se deben recorrer los nodos desde la
posicin del nodo eliminado hasta la raz revisando que
sus niveles cumplan con las reglas.
Al encontrarse una anomala, se ejecutan las
siguientes operaciones:
1. Se debe decrementar el nivel de un nodo cuando:
- Alguno de los hijos est ms de un nivel ms abajo.
- Un nodo hoja es hijo de otro nodo cuyo nivel ha
sido decrementado.
2. Torsionar el nivel de un nodo cuyo nivel fue
disminuido:
- Torsionar el sub-rbol desde la raz, donde el nodo
decrementado es la raz.
- Torsionar el hijo derecho de la raz.
- Torsionar el hijo derecho del hijo derecho de la
raz.
3. Dividir el nivel del nodo cuyo nivel fue
decrementado
- Dividir la raz del sub-rbol.
- Dividir el hijo derecho de la raz.
HEAP (MONTCULO)
Un montculo es una estructura de tipo rbol donde
sus elementos son parte de un conjunto ordenado. Como
caracterstica, en los montculos mximos, cada nodo
padre todo tiene un valor mayor que cada uno de sus
montculos hijos, mientras que, en los montculos
mnimos, el nodo padre es el menor de todos.
Un rbol cumple la condicin de montculo si alguna
de las dos condiciones anteriores, y es adems un rbol
casi completo. Se habla de completitud en un rbol
cuando todos los niveles estn llenos, exceptuando el
ltimo, que es llenado de izquierda a derecha.
Este tipo de rbol fue introducido por primera vez
por J W J Williams en 1964, inicialmente para el
algoritmo de ordenamiento heapsort.
Operaciones
Tanto la operacin de insertar, como tambin la de
eliminar, modifican el montculo para cumplir con las
propiedades de un rbol de tipo heap, mencionadas
anteriormente, al agregar o eliminar desde el final del
montculo. Posteriormente la condicin de montculo,
se restaura, desplazando hacia arriba o hacia abajo el
montn. Ambas operaciones tienen una complejidad de
O (log n).
Insercin
Para agregar un elemento al montculo, se agrega en
la posicin que respeta la restriccin de rbol semi
completo, pero posiblemente invalidando la propiedad
de montculo, para luego restaurar la propiedad de
montculo por el intercambio de valor de la posicin
desordenada por el valor de su padre. estas acciones se
pueden ver sintetizadas en el siguiente algoritmo.
Agregar el nuevo elemento en el ltimo nivel del
rbol en el orden que corresponde
Comparar el elemento agregado con su padre, si est
en el orden correcto, detenerse, si no intercambiar el
elemento con su padre y regresar al paso previo.
El nmero de operaciones requeridas depende
solamente del nmero de niveles que el elemento debe
saltar para satisfacer la propiedad de montculo. As, la
operacin de insercin tiene una complejidad en el peor
caso de O (log n), pero una complejidad de caso
promedio de O (1).
Comparacin Tcnicas y Algoritmos de Balanceo

/**
*Su respectivo constructor.
*/
public AATree( ) {
root = nullNode;
}

[5]
/**
Eliminacin de la Raz
*inserta en el arbol.
El procedimiento para eliminar la raz del montculo
*/
(el elemento mximo en un max-heap o el elemento
public void insert (Comparable x ) {
mnimo en un min-heap) se realiza con el siguiente
root = insert( x, root );
algoritmo.
}
1 Reemplazar la raz del montculo con el ltimo
elemento en el ltimo nivel
/**
2. Comparar la nueva raz con sus hijos. Si est en el
*Elimina elementos del arbol
orden correcto, detenerse.
*/
3. Si no, intercambiar el elemento con uno de sus
public void remove (Comparable x ) {
hijos y regresa al paso anterior (el intercambio se realiza
deletedNode = nullNode;
con su hijo ms pequeo en un min heap, y con su hijo
root = remove( x, root );
ms grande en un max-heap).
}

/**
*Encuentra el elemento mas pequeo del arbol
*/
public Comparable findMin( ) {
if( isEmpty( ) )
return null;

AANode ptr = root;

[6]
Implementacin del algoritmo AA Tree while( ptr.left != nullNode )
Se crea la clase AA Tree ptr = ptr.left;
public class AATree {
return ptr.element;
Comparacin Tcnicas y Algoritmos de Balanceo

}
/**
/** *Se mira que el rbol este lgicamente vaco
*Encuentra el elemento mas grande en el rbol */
*/ public void makeEmpty( ) {
public Comparable findMax( ) { root = nullNode;
if( isEmpty( ) ) }
return null;
/**
AANode ptr = root; * Comprueba si el rbol esta lgicamente vacio
*/
while( ptr.right != nullNode )
ptr = ptr.right; public boolean isEmpty( ) {
return root == nullNode;
return ptr.element; }
}
/**
/** * Mtodo interno para insertar en un subrbol
*Busca un elemento en el rbol */
*/ private AANode insert( Comparable x, AANode t ) {
public Comparable find (Comparable x ) { if( t == nullNode )
AANode current = root; t = new AANode( x );
nullNode.element = x; else if( x.compareTo( t.element ) < 0 )
t.left = insert( x, t.left );
for( ; ; ) { else if( x.compareTo( t.element ) > 0 )
if( x.compareTo (current.element ) < 0 ) t.right = insert( x, t.right );
current = current.left; else
else if( x.compareTo( current.element ) > 0 ) throw new DuplicateItemException( x.toString( ) );
current = current.right;
else if( current != nullNode ) t = skew( t );
return current.element; t = split( t );
else return t;
return null; }
}
}
Comparacin Tcnicas y Algoritmos de Balanceo

/** t.right.level = t.level;

* Metodo interno donde se puede eliminar en un t = skew( t );
subrbol t.right = skew( t.right );
*/ t.right.right = skew( t.right.right );
private AANode remove( Comparable x, AANode t ) { t = split( t );
if( t != nullNode ) { t.right = split( t.right );
// Busque en el rbol y establezca el ltimo nodo y el }
nodo eliminado }
lastNode = t; return t;
if( x.compareTo( t.element ) < 0 ) }
t.left = remove( x, t.left );
else { /**
deletedNode = t; *Se divide el rbol y se toma una nueva raz despus de
t.right = remove( x, t.right ); la */rotacin por izquierda
} private static AANode skew( AANode t ) {
if( t.left.level == t.level )
t = rotateWithLeftChild( t );
/** return t;
* Si en la parte inferior del rbol X est presente lo }
retiramos //Se divide el rbol y se toma una nueva raz despus de
*/ la rotacin //por derecha
if( t == lastNode ) {
if( deletedNode == nullNode || x.compareTo( private static AANode split( AANode t ) {
deletedNode.element ) != 0 ) if( t.right.right.level == t.level ) {
throw new ItemNotFoundException( x.toString( ) ); t = rotateWithRightChild( t );
deletedNode.element = t.element; t.level++;
t = t.right; }
} return t;
}
/**
* Si lo retiramos se vuelve a rebalancear /**
*/ * Rotar el nodo del rbol binario con el hijo izquierdo.
else */
if( t.left.level < t.level - 1 || t.right.level < t.level - 1 ) { private static AANode rotateWithLeftChild( AANode
if( t.right.level > --t.level ) k2 ) {
Comparacin Tcnicas y Algoritmos de Balanceo

AANode k1 = k2.left; private static AANode nullNode;

k2.left = k1.right;
k1.right = k2; /**
return k1; * Inicializa los datos del nodo
} */
/** {
* Rota el nodo del rbol con el hijo derecho nullNode = new AANode( null );
*/ nullNode.left = nullNode.right = nullNode;
private static AANode rotateWithRightChild( AANode nullNode.level = 0;
k1 ) { }
AANode k2 = k1.right;
k1.right = k2.left; private static AANode deletedNode;
k2.left = k1; private static AANode lastNode;
return k2;
} /**
/** * Se crea la clase Test donde se debe imprimir el min y
* Creamos una clase AANode * el max
*/ */
public static void main( String [ ] args ) {
private static class AANode { AATree t = new AATree( );
Su constructor final int NUMS = 40000;
AANode (Comparable theElement ) { final int GAP = 307;
element = theElement;
left = right = nullNode; System.out.println("Checking... (no bad output means
level = 1; success)" );
}
t.insert( new Integer( NUMS * 2 ) );
Comparable element; //tenemos los datos necesarios t.insert( new Integer( NUMS * 3 ) );
del nodo for( int i = GAP; i != 0; i = ( i + GAP ) % NUMS )
AANode left; t.insert( new Integer( i ) );
AANode right; System.out.println( "Inserts complete" );
int level;
} t.remove( t.findMax( ) );
for( int i = 1; i < NUMS; i+= 2 )
private AANode root; t.remove( new Integer( i ) );
Comparacin Tcnicas y Algoritmos de Balanceo

t.remove( t.findMax( ) ); especialmente cuando se trata de grandes volmenes de

System.out.println( "Removes complete" ); datos y con problemas de gran complejidad.
En este artculo se encuentra dos cdigos en los que
if( ((Integer)(t.findMin( ))).intValue( ) != 2 || se tendr encuentra la complejidad de cada uno, y se
((Integer)(t.findMax( ))).intValue( ) != NUMS - 2 ) conocer cul de estos cumple esta condicin al
System.out.println( "FindMin or FindMax error!" ); momento de su ejecucin, este tipo de problemas se
observan al momento de ingresar una gran cantidad de
for( int i = 2; i < NUMS; i+=2 ) datos.
if( ((Integer)t.find( new Integer( i ) )).intValue( ) != i ) En el caso de mximos y mnimos Heap o bien
System.out.println( "Error: find fails for " + i ); llamado Montculo cuenta con el nmero de
operaciones requeridas, el cual depende solamente del
for( int i = 1; i < NUMS; i+=2 ) nmero de niveles que el elemento debe saltar para
if( t.find( new Integer( i ) ) != null ) satisfacer la propiedad de montculo.
System.out.println( "Error: Found deleted item " + i ); As al momento de generar la insercin este tiene una
} complejidad en el peor de los casos de O (log n), pero
} en el caso promedio de O (1), teniendo en cuenta que
este algoritmo fue diseado para colas de prioridad es
/** decir puede llegar a jerarquizar los datos para hacer que
* La clase excepcin se tiene para errores duplicados sea ms fcil acceder a los datos de menor o mayor
*/ tamao.
public class DuplicateItemException extends Por otra parte, el rbol AA al igual que el Heap tiene
RuntimeException { una complejidad de O (log n) es eficiente al momento
de generar una bsqueda de datos puede llegar a
Constructor. almacenar, recuperar informacin.
public DuplicateItemException( ) { Si comparamos estos algoritmos vemos que cada
super( ); uno es eficiente dependiendo de su uso si, se necesita
} almacenar datos y recuperar informacin el rbol AA
ser complejo y eficiente, si vemos el rbol de
public DuplicateItemException( String message ) { montculo ser complejo segn la prioridad que se
super( message ); requiera, donde el valor de su prioridad puede ser mayor
} o menor.
}
ANLISIS
Una caracterstica importante de un algoritmo
implementado es el tiempo que se toma en ejecucin,
Comparacin Tcnicas y Algoritmos de Balanceo

CONCLUSIONES BIBLIOGRAFA
En primer lugar, se dio a conocer el Bijit, L. S. (20 de Enero de 2010). rboles AA. En L. S.
funcionamiento y aplicacin de algoritmos que son Bijit, Estructuras de Datos y Algoritmos (pgs. 1-
diseados recursivamente segn su forma de empleo. 27).
Por otra parte, en el anlisis de los algoritmos y Maldonado, M. (10 de Abril de 2005). Introduccin la
su eficiencia podremos interpretar la complejidad y el estructura heap. Obtenido de
mejor diseo al momento de implementar los http://slideplayer.es/slide/3488238/
algoritmos dndonos cuenta de su complejidad en el MEG. (13 de Abril de 2009). Estructuras de datos y
peor de los casos. algoritmos. Obtenido de
Es importante tener en cuenta que un rbol tiene http://estructuradedatosyalgoritmos.blogspot.com.c
una estructura de datos que nos permite almacenar una o/2009/04/monton-o-heap.html
cantidad significativa de datos de forma ordenada Thomas Wilburn. (10 de Noviembre de 2013).
siendo esto una parte importante al momento de Adventures in data structure: AA Trees. Obtenido de
implementacin y manejo de tipos de rboles segn lo http://thomaswilburn.net/typedefs/index.php/tree/aa
requiera el usuario. /aa_trees.html

REFERENCIAS DE FIGURAS
[1] Torsin en AA Tree. Arne Anderson. Balanced
Search Trees Made Simple. 1993.
[2] Divisin en AA Tree. Arne Anderson. Balanced
Search Trees Made Simple. 1993.
[3] Insercin en AA Tree. Leopoldo Silva Bijit.
rboles AA. 2010.
[4] Eliminar en AA Tree. Leopoldo Silva Bijit.
rboles AA. 2010.
[5] Insercin en Max Heap. En lnea. Disponible en:
http://estructuradedatosyalgoritmos.blogspot.com.co/2
009/04/monton-o-heap.html99999
[6] Eliminacin del mximo elemento del rbol. En
lnea. Disponible en: http://estructuradedatosyalgor
itmos.blogspot.com.co/2009/04/monton-o-heap.html