9. Árboles. Una estructura de datos con una relación es una árbol si y sólo:

Transcripción

1 9. Árboles Una estructura de datos con una relación es una árbol si y sólo: La relación es conexa, es decir, existe una composición de relaciones entre cualquier par de nodos en el árbol. No admite ciclos. Definición: Un árbol T es un conjunto finito de uno o más nodos tal que: (i) hay un nodo especialmente llamado raíz R; (ii) los demás nodos están particionados en n 0 conjuntos desconectados T 1... T n, donde cada uno de estos conjuntos es un árbol, así llamados subárboles de la raíz. sí: Padre: El nodo inmediatamente antecesor Hijos: nodos inmediatamente sucesor Grado: número de hijos de un nodo Nivel: distancia a la raíz de un nodo Profundidad: nivel máximo de un árbol osque: árboles desconectados Formas de visualizar un árbol son: Gráfico: T = {R} T 1... T n T i T n = (2) D E F G H I J K L M Listas: (((E(K,L),F),(G),D(H(M),I,J))) 50

2 Data G 0 0 D F 0 0 H 0 M 0 0 E 0 K 0 L 0 0 I 0 J 0 La representación es esencialmente por listas encadenadas Teoremas: El árbol es conexo pero al eliminar un arco, se convierte en no conexo El árbol no tiene ciclos y es conexo, arcos = nodos 1 l agregar un arco a un árbol se crea un ciclo. 10. Árbol inario Definición: Un árbol binario es un número finito de nodos que es vacío o consiste de una raíz con dos árboles binarios desconectados llamados subárbol izquierdo y derecho. Se llaman los nodos que no tienen hijos, nodos hojas o terminales. Nodos con uno o dos hijos son llamados nodos internos. 51

3 structuretree(item) declare NEW () btree M KET REE(btree, item, btree) btree LHILD(btree) btree RHILD(btree) btree DT (btree) item IS IN(btree, item) boolean IS EMP T Y (btree) boolean for all bt 1, bt 2 T REE, i, i 1, i 2 item let DT (NEW ()) ::= error DT (MKET REE(bt 1, i, bt 2 )) ::= i IS EMP T Y (NEW ()) ::= true IS EMP T Y (MKET REE(bt 1, i, bt 2 )) ::= false IS IN(NEW (), i) ::= false IS IN(MKET REE(bt 1, i 1, bt 2 ), i 2 ) ::= if i 1 = i 2 then true else IS IN(bt 1, i 2 ) IS IN(bt 2, i 2 ) LHILD(NEW ()) ::= NEW () LHILD(MKET REE(bt 1, i, bt 2 )) ::= bt 1 RHILD(NEW ()) ::= NEW () RHILD(MKET REE(bt 1, i, bt 2 )) ::= bt 2 Lema: El máximo número de nodos en un nivel i de un árbol binario es 2 i, i 0; y el máximo número de nodos en un árbol binario de profundidad k es 2 k+1 1, k 0. Prueba Por inducción ase inducción: La raíz es el único nodo en el nivel 0. Por lo tanto, el máximo número de nodos en el nivel i = 0 es 2 0 = 2 i. Hipótesis de inducción: Para todo j, 0 j i, el máximo número de nodos en el nivel j es 2 j. Paso de inducción: El máximo número de nodos en el nivel i 1 es 2 i 1, por la hipótesis de inducción. Debido a que cada nodo del árbol tiene como máximo grado 2, el número de nodos máximos en el nivel i es 2 veces el máximo número de nodos en el nivel i 1 o 2 i. El máximo número de nodos n en un árbol binario de profundidad k es la sumatoria del máximo número de nodos en cada nivel: k n = 2 i = 2 k+1 1 i=0 Lema: Por cada árbol binario no vacío T, si n es el número de nodos terminales (hojas) y m es el número de nodos de grado 2, entonces n = m + 1. Prueba: Sea l el número de nodos de grado uno, entonces el número total de nodos N en el árbol es N = n + m + l. Todos los nodos en el árbol excepto por la raíz tienen un arco de llegada. Entonces, N es igual al número de arcos + 1. También, todo arco emana de un nodo de grado uno o de grado dos. sí: = l + 2m. Por lo tanto N = 1 + l + 2m. Substrayendo N = 1 + l + 2m de N = n + m + l nos queda que n = m

4 10.1. Representación por arreglos Un árbol binario se representa en un arreglo del siguiente modo: si un nodo ocupa la posición i, entonces su hijo izquierdo ocupa la posición 2i y su hijo derecho la posición 2i + 1. Si un árbol es completo con n nodos, por cada nodo i, 1 i n, tenemos: PRENT(i) está localizado en i/2 si i 1. uando i = 1, i es la raíz y no tiene padre. LHILD(i) está en 2i si 2i n. Si 2i > n entonces no tiene hijo izquierdo. RHILD(i) está en 2i + 1 si 2i + 1 n. Si 2i + 1 > n, entonces no tiene hijo derecho. Esta forma de representación no es muy usada por problemas de pérdida de espacio Representación por punteros Usando punteros, cada nodo es un registro con tres campos: el dato, el puntero al hijo izquierdo y el puntero al hijo derecho. aminamiento en un árboles binario T : Procedure IN ORDER(T ) if T nil do [ call IN ORDER(LHILD(T )) print(dt(t)) call IN ORDER(RHILD(T )) ] end INORDER Procedure P REORDER(T ) if T nil do [ print(dt(t)) call P REORDER(LHILD(T )) call P REORDER(RHILD(T )) ] end P REORDER Procedure P OST ORDER(T ) if T nil do [ call P OST ORDER(LHILD(T )) call P OST ORDER(RHILD(T )) print(dt(t)) ] end P OST ORDER Si T es un árbol binario con raíz de n nodos, el caminamiento en el árbol toma Θ(n). Sea T (n) el tiempo que toma el recorrido de un árbol binario de n nodos. El menor tiempo posible es el de un árbol vacío T (0) = c para alguna constante positiva c. Para n > 0, suponga que la llamada al recorrido ocurrió en un nodo x raíz con k nodos en el subárbol izquierdo y n k 1 hijos en el subárbol derecho. El tiempo de recorrido es T (n) = T (k)+t (n k 1)+dparaalgunaconstantepositivad que refleja el tiempo de ejecución en el nodo raíz (o sea, el tiempo de las llamadas recursivas esencialmente). Provemos que T (n) = (c+d)n+c. Para n = 0, nosotros tenemos que (c+d)0+c = c = T (0). 53

5 Para n > 0 tenemos que: T (n) = T (k) + T (n k 1) + d = ((c + d)k + c) + ((c + d)(n k 1) + c) + d = (c + d)n + c (c + d) + c + d = (c + d)n + c (3) Esto demuestra que T (n) = (c + d)n + c y esto es Θ(n) Árboles inarios de úsqueda Un árbol binario de búsqueda es un árbol binario donde la raíz es siempre mayor que los nodos del subárbol izquierdo y menor que todos los nodos del subárbol derecho. structuretree(item) declare NEW () bbtree M T REE(bbtree, item, bbtree) btree IN SERT (item, bbtree) bbtree IS EMP T Y (btree) boolean IS IN(bbtree, item) boolean MINIMUM(bbtree) item MXIMUM(bbtree) item for all bt 1, bt 2 T REE, i, i 1, i 2 item let INSERT (i, NEW ()) ::= MT REE(NEW (), i, NEW ()) INSERT (i, MT REE(bbt 1, i, bbt 2 )) ::= MT REE(bbt 1, i, bbt 2 ) INSERT (i, MT REE(bbt 1, i 2, NEW ())) ::= if i > i 2 then MT REE(bbt 1, i 2, MT REE(NEW (), i, NEW ())) else MT REE(INSERT (i, bbt 1 ), i 2, NEW ()) INSERT (i, MT REE(NEW (), i 2, bbt 2 )) ::= if i < i 2 then MT REE(MT REE(NEW (), i, NEW ()), i 2, bbt 2 ) else MT REE(NEW (), i 2, INSERT (i, bbt 1 )) INSERT (i, MT REE(bbt 1, i 2, bbt 2 )) ::= if i < i 2 then MT REE(INSERT (i, bbt 1 ), i 2, bbt 2 ) else MT REE(bbt 1, i 2, INSERT (i, bbt 1 )) IS EMP T Y (NEW ()) ::= true IS EMP T Y (MT REE(bbt 1, i, bbt 2 )) ::= false IS IN(NEW (), i) ::= false IS IN(MT REE(bbt 1, i 1, bbt 2 ), i 2 ) ::= if i 1 = i 2 then true else if i 2 < i 1 then IS IN(bt 1, i 2 ) else IS IN(bt 2, i 2 ) MINIMUM(NEW ()) ::= error MINIMUM(MT REE(NEW (), i, bbt 2 )) ::= i MINIMUM(MT REE(bbt 1, i, bbt 2 )) ::= MINIMUM(bbt 1 ) MXIMUM(NEW ()) ::= error MXIMUM(MT REE(bbt 1, i, NEW ())) ::= i MXIMUM(MT REE(bbt 1, i, bbt 2 )) ::= MXIMUM(bbt 2 ) 54

6 Los algoritmos de árboles binarios de búsqeuda son: úsqueda: Procedure USR(N, T ) // N es el valor buscado // T es la raíz del árbol binario de búsqueda if T nil do [ if N = DT (T ) then return T else if N < DT (T ) then return USR(N, LHILD(T )) else USR(N, RHILD(T )) ] else return no se encontró end USR Procedure USR(N, T ) // no recursivo // N es el valor buscado // T es la raíz del árbol binario de búsqueda p := T while p nil do [ if N = DT (p) then return p else if N < DT (p) then p := LHILD(p) else p := RHILD(p) ] return no se encontró end USR En el peor caso, la búsqueda llega hasta la hoja de unárbol pasando por un camino desde la raíz hata la hoja, es decir, es un camino de largo h, con h siendo la profundidad. Mínimo y Máximo: Procedure MINIMUM(x) // x nodo del árbol binario de búsqueda while LHILD(x) nil do [ x := LHILD(x) ] return x end MINIMUM Procedure MXIMUM(x) // x es un nodo del árbol binario de búsqueda while RHILD(x) nil do [ x := RHILD(x) ] return x end MXIMUM mbos lgoritmos tienen complejidad O(h) ya que ambos siguen el camino desde la raíz a la hoja más izquierda o derecha del árbol. Sucesor y Predecesor: 55

7 Procedure SU ESSOR(x) // x es un nodo en el árbol //P RENT (x) obtiene el padre de x if RHILD(x) nil then return MINIMUM(RHILD(x)) y := P RENT (x) while y nil and x = RHILD(y) do [ x := y y := P RENT (y) ] return y end SU ESSOR Si un nodo x tiene un subárbol derecho, el sucesor y es el mínimo valor del subárbol derecho. Si un nodo no tiene subárbol derecho y tiene sucesor y, entonces, el sucesor y es el menor ancestor de x cuyo hijo izquierdo es también un ancestor de x. La complejidad del algoritmo es O(h) porque sigue el camino hacia una hoja del subárbol derecho o sigue hacia arriba el camino hasta la raíz El algoritmo P redecessor(x) es simétrico y con el mismas complejidad. Insertar y orrar: Procedure INSERT R(P, T ) // P es el nodo a insertar // T es la raíz del árbol binario de búsqueda if DT (T ) = DT (P ) then return existe else if DT (P ) < DT (T ) then [ if LHILD(T ) = nil then [ LHILD(T):= P return ] else IN SERT R(P, LHILD(T ))] else if RHILD(T ) = nil then[ RHILD(T):= P return ] else IN SERT R(P, RHILD(T )) end INSERT R En el peor caso, la inserción en un árbol se hace en un nodo hoja, lo que queda dado por la profundidad del árbol O(h)antes de insertar. Ojo, al insertar, esta profundidad puede variar. 56

8 Procedure DELET E(P, T ) // P es el nodo a eliminar // T es la raíz del árbol binario de búsqueda if LHILD(P ) = nil and RHILD(P ) = nil then y := P else y := SUESSOR(P ) if LHILD(y) nil then x := LHILD(y) else x := RHILD(y) if x nil then [ P RENT (x) := P RENT (y) if P RENT (y) = nil then T := x else if y = LHILD(P RENT (y)) then LHILD(P RENT (y)) := x else RHILD(P RENT (y)) := x if y x then DT(P) := DT(y) copia de información de punteros return y end DELET E Para borrar se consideran 3 casos. Si P no tiene hijos, modifique el padre de P para reemplazar P por nil como su hijo. N N H T H T L R U D K M P I J L R U D K I J 57

9 Si P tiene sólo un hijo, se divide P haciendo un nuevo enlace entre su hijo y su padre. N N H T H T L R U D K M P I L R U D I M P J J Finalmente, si el nodo tiene dos hijos, se divide el sucesor de P, y, el cual no tiene hijo izquierdo y se reemplaza la clave de P y sus punteros con la clave de y y sus información de punteros. N N H T I T L R U D K M P I L R U D K M P J J Problema: La eficiencia de un método depende de que el árbol de búsqueda esté balanceado. Entonces, cómo mantener el árbol balanceado? Definición: en un árbol de búsqueda balanceado (VL) la profundidad del subárbol izquierdo es igual a la profundidad del subárbol derecho ±1. su vez, esta profundidad es satisfecha recursivamente por los subárboles. Por ejemplo: 58

10 M H T J R U D P Supongamos que tenemos un árbol binario de búsqueda balanceado y le insertamos un nuevo nodo. El caso simple es cuando el árbol continua siendo balanceado. El problema sucede cuando al insertar el nodo, se desbalancea el árbol. Eso sucede en dos caso posibles: La solución es rotar el árbol una vez insertado el nodo. En el primer caso, la rotación es simple y se hace en el sentido contrario al desbalanceo. El segundo caso, es necesario hacer dos rotaciones ya que el desbalanceo se produce en el sentido contrario a la inserción: 59

11 + D D + En ambos casos, los árboles resultantes mantienen la profundidad inicial. Otra situación a considerar es al borrar un nodo de un árbol que está balanceado y que se desbalancea. D D l igual que para inserción se deben realizar rotaciones. diferencia de cuando se inserta, sin embargo, los árboles resultantes pueden cambiar su profundidad y por lo tanto, no se puede garantizar que el balanceo del subárbol mantenga el rbol que lo contenga balanceado. En resumen: l insertar: 1. usar búsqueda binaria para ver donde insertar, e insertar el nodo 2. desde allí hacia arriba, chequear donde ocurre el desbalanceo. 3. hacer la rotación adecuada. l eliminar: 1. borrar el nodo 2. ubicar punto de desbalanceo (único si existe) 3. hacer la rotactión correspondiente 60

12 4. si cambió profundidad volver al punto 2 Por ejemplo, en la siguiente figura, al ingresar la clave 20 se producen dos desbalances. La rotación sobre el nodo con valor 11 soluciona sólo un debalance rotación izquierda Sin embargo, al tomar el desbalance mas profundo (más cercano a la hoja donde se inserta el elemento) y su balanceo, el árbol vuelve a estar balanceado. 61

13 rotación doble lgoritmos de rotación: sume que X tiene hijo derecho. Y right rotation(t,y) X X γ left rotation(t,y) α Y α β β γ 62

14 Procedure LEF T ROT T ION(T, x) // x nodo de rotatción // T es la raíz del árbol binario de búsqueda y := RHILD(x) RHILD(x) := LHILD(y) if LHILD(y) nil then P RENT (LHILD(y)) := x P RENT (y) := P RENT (x) if P RENT (x) = nil then T := y else if x = LHILD(P RENT (x)) then LHILD(P RENT (x)) := y else RHILD(P RENT (x)) := y LHILD(y) := x PRENT(x) := y end LEF T ROT T ION(T, x) 63

15 Ejercicios de árboles binarios y árboles binarios de búsqueda 1. ombinando preorden con inorder. Dado una secuencia de un árbol binario en preorden y otra en inorden, es posible definir el único árbol que las define. Suponga la siguiente secuencia en preorden: D E F G H I y la secuencia en inorden: E D G H F I, se puede construir el árbol binario haciendo que la primera letra en preorden sea la raíz y al consider la definición en inorden de que todos los antecesores de sean los hijos izquierdo y los restantes en el lado derecho. Eso nos queda:, D,E,F,G,H,I Moviéndose a continuación de la secuencia en preorden está como la próxima raíz y por la secuencia en inorden se tiene que no tiene hijo izquierdo y un subárbol derecho con. D,E,F,G,H,I ontinuando de esta manera, se llega a: D E F G J H Se puede decir que cada árbol binario tiene un único par de secuencias pre-orden-inorden. 2. ontando árboles binarios. Para 0 o 1 nodo, se tiene 1 posible árbol binario. 64

16 Para 2 nodos, se tiene 2 posibles árboles binarios. Para 3 nodos, se tienen 5.. Para n? Si los nodos de un árbol son enumerados en una secuencia de preorden de 1... n, entonces por el ejercicio anterior, distintos árbol binarios definen distintas secuencias en inorden (permutaciones en inorden). Usando el concepto de permutación en inorden, es posible mostrar que el número total de distintas permutaciones pasando los 1... n nodes a través de una pila y borrándolas en todas las formas posibles es igual al número total de árboles binarios con n nodos. omenzemos con 3 nodos (1... 3), las posibles secuencias son: 1,2,3;3,2,1;2,1,3;2,3,1;3,2,1 ada una de estas permutaciones corresponde a uno de los 5 árboles posibles: En forma más general, queremos una expresión bn de los números de árboles binarios distintos con n nodos. Se puede deducir que b n es la suma de todos los posibles árboles binarios de la siguiente forma, una raíz y dos subrboles b i, b n i 1 : on recurrencia b n = b i b n i 1, n 1 b 0 = 1 0 i n 1 (x) = i 0 b i x i con Por teorema binomial (0) = b 0 = 1 (x) = 1 1 4x 2x (x) = m 0 ( 1/2 m + 1 ) ( 1) m 2 2m+1 x m 65

17 omparando las ecuaciones anteriores, b n es el coeficiente de x n en (x): b n ) = 1 ( 2n n + 1 n ) b n = O( 4n n 3/2 ) 3. Extensión de la definición algebraica de un árbol binario. Defina las funciones: P REORDER(btree) queue IN ORDER(btree) queue P OST ORDER(btree) queue usando la definición P P END(queue, queue) queue Defina, además, una función que realice el SW P T REE(btree) btree que invierte los hijos izquierdos y derechos en forma recursiva y la función que entrega el número de nodos hojas de un btree NUM LEV ES(btree) int. P REORDER(RET E) ::= EMP T Y QUEUE P REORDER(MKET (l, d, r)) ::= P P END(P P END(DDQ(EMP T Y QUEUE, d), (P REORDER(l))), (P REORDER(r))) INORDER(RET E) ::= EMP T Y QUEUE INORDER(MKET (l, d, r)) ::= P P END(P P END((INORDER(l)), DDQ(EMP T Y QUEUE, d)), (INORDER(l))) P OST ORDER(RET E) ::= EMP T Y QUEUE P OST ORDER(MKET (l, d, r)) ::= P P END(P P END((P OST ORDER(l)), (P OST ORDER(l))), DDQ(EMP T Y QUEUE, d)) SW P T REE(RET E) ::= RET E SW P T REE(MKET (l, d, r)) ::= MKET (SW P T REE(r), d, SW P T REE(l)) NUM LEV ES(RET E) ::= 0 NUM LEV ES(MKET (l, d, r)) ::= if ISEMT T (l) and ISEMT T (r) then 1 else NUM LEV ES(l) + NUM LEV ES(r) 4. Árboles ompletos: Un árbol con altura h es completo si tiene todos los niveles llenos hasta el nivel h (ojo, se asume aquí que a la altura h, el nivel es h + 1). El nivel h + 1 está lleno de izquierda a derecha y a partir de un punto en adelante está vacío. Escriba un algoritmo que indique si el árbol está o no lleno. 5. Árboles atados: Árboles atados son aquellos donde los nodos nulos de un árbol binario tradicional son usados para asociar el nodo al nodo sucesor o antecesor en el recorrido del árbol en un determinado orden (INORDER, POSTORDER, PREORDER). En la siguiente figura se muestra un árbol atado para un recorrido en inorder que apoya los algoritmos de sucesor o predecesor. lgunos algoritmos para estos árboles son: 66

18 I 0 D H E punteros adicional punteros originales F G Figura 20: Árboles tados Encontrar el sucesor en inorder de un nodo N en un árbol atado. Procedure SU ESSOR(var N oden) //Sea N el nodo en un árbol atado en inorder para el cual se desea encontrar el sucesor. // N retornará el valor del sucesor N := RLINK(N) if N es un puntero de atadura o N = nil then termina while LLINK(N) no sea un puntero de atadura do N := LHILD(N) endsu ESSOR Recorrer en inorder un árbo atado en inorder Procedure W LK(N oder) //Sea R la raíz del árbol atado N := R while LLINK(N) nil do N := LHILD(N) Visite N N := SUESOR(N) while N nil do [ visite N N := SUESOR(N)] endw LK Insertar un subárbol atado T 1 como subárbol derecho de un nodo N en otro subárbol atado T 2. Procedure INSERT R(var noden, nodert 1 ) // RT 1 es la raíz de T 1 R := RT 1 S := N repeat S := RHILD(S) until S es una atadura o S = nil RLINK(N) := R Q := R while RLINK(Q) no sea una atadura y RLINK(Q) nil do Q := RLINK(Q) RLINK(Q) := S Q := R while LLINK(Q) no sea una atadura y LLINK(Q) nil do Q := LLINK(Q) LLINK(Q) := N endin SERT R 67