1

Árboles de Búsqueda Binaria

Agustín J. GonzálezELO-320: Estructura de Datos y

Algoritmos

2

Introducción Los árboles de búsqueda son estructuras de datos que soportan

las siguientes operaciones de conjuntos dinámicos:Search -Búsqueda-, Minimum, Maximum, Predecessor, Successor, Insert, y Delete.

Los árboles de búsqueda se pueden utilizar como diccionarios y como colas de prioridad.

Estas operaciones toman un tiempo proporcional a la altura del árbol.

Para un árbol completo binario esto es (lg n) en el peor caso; sin embargo, si el árbol es una cadena lineal de n nodos, las mismas operaciones toman (n) en el peor caso.

Para árboles creados aleatoriamente, la altura es O(lg n), con lo cual los tiempos son (lg n).

Hay varios esquemas para mejorar el peor caso de los árboles de búsqueda. Dos de ellos son los árboles 2-3 y los árboles rojo-negro.

3

Sea x un nodo en un árbol de búsqueda binaria. Si y es un nodo del sub-árbol izquierdo de x, entonces se cumple: (clave de y) (clave de x). Si z es un nodo del sub-árbol dercho de x, entonces la se cumple (clave de x) (clave de z).

Por ejemplo, dos árboles de búsqueda binaria son:

La propiedad de árbol nos permite recorrer o imprimir sus nodos en el orden de sus claves haciendo uso de un simple algoritmo recursivo.

5

2 5

73

8

23

7

5 8

5

x

yx

zx

Propiedad de un árbol búsqueda binaria

y z

4

Recorrido Inorder de un árbol búsqueda binaria

Suponiendo una estructura como la vista antes para árboles binarios, tenemos: typedef struct arbol_tag {

struct arbol_tag * p;struct arbol_tag * left;struct arbol_tab * right;elementType element;

} TREE_NODE; void Inorder_Tree_Walk( TREE_NODE * x) {

if (x != NULL) {Inorder_Tree_Walk(x->left);Print(x->element); /* podría ser procesar elemento*/Inorder_Tree_Walk(x->right);

}}

Este algoritmo toma tiempo (n) porque el procedimiento es llamado exactamente dos veces por cada nodo.

Análogamente se definen recorridos preorder y postorder del árbol. El único cambio es el lugar de la instrucción de procesamiento del nodo. En preorder, el nodo se procesa primero y en postorder se procesa después.

5

void Preorder_Tree_Walk( TREE_NODE * x) {if (x != NULL) {

Print(x->element); /* podría ser procesar elemento*/Preorder_Tree_Walk(x->left);Preorder_Tree_Walk(x->right);

}}

void Postorder_Tree_Walk( TREE_NODE * x) {if (x != NULL) {

Postorder_Tree_Walk(x->left);Postorder_Tree_Walk(x->right);Print(x->element); /* podría ser procesar elemento*/

}}

El recorrido del árbol con los algoritmos previos daría: Preorder: 5, 3, 2, 5, 7, 8 Inorder: 2, 3, 5, 5, 7, 8 Postorder: 2, 5, 3, 8, 7, 5

5

2 5

73

8

Recorrido Pre y port-order de un árbol búsqueda binaria

6

Otras operaciones en un árbol de búsqueda binaria

Búsqueda de una clave determinada:TREE_NODE * Tree_Search( TREE_NODE * x, elementType k) {

if (x == NULL) return x;else if (x->element == k ) /* Ojo: esta comparación

podría ser una función*/return x;

else if (k < x->element) return Tree_Search( x->left, k);

else return Tree_Search( x->right, k);

} El tiempo de este algoritmo es O(h) donde h es la altura del

árbol. Este procedimiento se puede “desenrollar” para eliminar el

tiempo de múltiples llamados a la misma función. Ver -->

7

Otras operaciones en un árbol de búsqueda binaria

Búsqueda de una clave determinada:

TREE_NODE * Tree_Search( TREE_NODE * x, elementType k) {

while(x != NULL) if (x->element == k )

return x;else if (k < x->element)

x = x->left;else

x= x->right;return x;

}

8

Máximo y Mínimo en un árbol de búsqueda binaria

TREE_NODE * Tree_Maximum( TREE_NODE * x) {if (x == NULL) return x;while (x->right != NULL )

x = x->right;return x;

}

TREE_NODE * Tree_Minimum( TREE_NODE * x) {if (x == NULL) return x;while (x->left != NULL )

x = x->left;return x;

}

9

Sucesor y Antecesor en un árbol de búsqueda binaria

TREE_NODE * Tree_Successor( TREE_NODE * x) {TREE_NODE * y;

if (x == NULL) return x;if (x->right != NULL)

return Tree_Minimum(x->right);y = x->p;while ( y != NULL )

if (x == y->right) {x = y;y = y->p;

}else break;

return y;}

10

Sucesor y Antecesor en un árbol de búsqueda binaria

TREE_NODE * Tree_Predecessor( TREE_NODE * x) {TREE_NODE * y;

if (x == NULL) return x;if (x->left != NULL)

return Tree_Maximum(x->left);y = x->p;while ( y != NULL )

if (x == y->left) {x = y;y = y->p;

}else break;

return y;}

11

Inserción en un árbol de búsqueda binaria

Suponemos inicialmente que z->left = z->right = NULL. Void Tree_Insert( TREE_NODE ** T, TREE_NODE * z) {

TREE_NODE *y, *x;y=NULL;x = *T;while (x != NULL) { /* buscamos quien debe ser su padre */

y = x; if ( z->element < x->element)

x = x->left;else

x= x->right;}z->p = y;if (y == NULL) /* se trata del primer nodo */

*T = z;else if (z->element < y->element)

y->left = z;else

y->right = z;}

Como el procedimiento de búsqueda, este algoritmo toma un tiempo O(h), h es la altura del árbol.

12

15

5 163 12 20

1810 23

6

7

15

5 163 12 20

13 1810 23

6

7

z

15

5 163 12 20

13 1810 23

6

7

z15

53 12

20

13

18

10

23

6

7

1)

2)

Eliminación en un árbol de búsqueda binaria

Como entrada disponemos de z, un puntero al nodo a remover.

Hay tres casos a considerar: 1.- Que *z sea un nodo hoja.

En este caso se elimina fácilmente.

2.- Que *z sea un nodo sin hijo izquierdo o derecho. En este caso, su único sub-árbol sube para toma el lugar de *z.

3.-*z posee dos sub-árboles. En este caso, su sucesor no posee hijo izquierdo, luego éste puede ser movido desde su posición a la de *z.

13

15

5 163 12 20

13 1810 23

6

7

z

7

15

5 163 12 20

13 1810 23

6

z

15

5 163 12 20

13 1810 23

7

z

6

15

6 163 12 20

13 1810 23

7

Eliminación tercer caso

Caso 3)

14

Eliminación: Algoritmo TREE_NODE * Tree-Delete(TREE_NODE **T, TREE_NODE * z) {

TREE:_NODE * x;if (z->left == NULL || z->right == NULL)

y = z; /* caso 1 y 2 */ else

y = Tree_Successor(z); /* caso 3 *//* hasta aquí y es un nodo con menos de dos hijos y debe ser extraído del árbol*/

if (y->left != NULL) x = y->left; else

x = y->right;if (x != NULL) x->p = y->p;if (y->p == NULL) /* estoy eliminado el último nodo */

*T = x;else if (y == y->p->left) /* y es hijo izquierdo */

y->p->left = x;else

y->p->right = x;if (y !=z) /* caso 3 */

z->element = y->element;return y;

}

15

Ejercicio: Proponga un algoritmo codificado en C o pseudo lenguaje

que reciba como entrada un puntero a la raíz de un árbol binario y retorne su altura. (Ayuda: observe que la altura de un nodo es uno más que la altura mayor de sus hijos)

Sea la siguiente estructura para cada nodo del árbol:typedef struct nodo_arbol {

struct nodo_arbol * p; /* puntero al padre */struct nodo_arbol * left; /* hijo izquierdo */struct nodo_arbol * right; /* hijo derecho*/ELEMENTO elemento;

} NODO_ARBOL;int Altura (NODO_ARBOL * T) {

int le, ri;if (T==NULL) return -1; /* en realidad no está definida la

altura en este caso (por observación de Manuel Jander 2003)*/le = Altura(T->left);ri = Altura(T->right);if (le > ri) return(le+1);else return (ri+1);

}

16

Divertimento

Antes de que pasara lo que pasara (lo que todos sabemos que pasó), los hijos de Adán y Eva estaban muy unidos.

Si Abel iba a la fiesta, Set también iba. Si Set no iba a la fiesta, Caín tampoco. Al menos uno de los tres fue a la fiesta.

¿Quién es el que fue?

Gentileza de (Orlando Pinto)