Arboles Binarios C 2

PROGRAMACION II
PROFESORA: MARIA ELENA CELIBERTI
20/08/2009
ARBOL BINARIO DE BUSQUEDA

Se trata de rboles de orden 2 en los que se cumple que para cada nodo, el valor de la clave de la raz del
subrbol izquierdo es menor que el valor de la clave del nodo y que el valor de la clave raz del subrbol derecho
es mayor que el valor de la clave del nodo.
OPERACIONES
El repertorio de operaciones que se pueden realizar sobre un ABB es parecido al que realizbamos sobre otras
estructuras de datos, ms alguna otra propia de rboles:
Buscar un elemento.
Insertar un elemento.
Borrar un elemento.
Movimientos a travs del rbol:
o Izquierda.
o Derecha.
o Raiz.
Informacin:
o Comprobar si un rbol est vaco.
o Calcular el nmero de nodos.
o Comprobar si el nodo es hoja.
o Calcular la altura de un nodo.
o Calcular la altura de un rbol.
BUSCAR UN ELEMENTO
Partiendo siempre del nodo raz, el modo de buscar un elemento se define de forma recursiva.
Si el rbol est vaco, terminamos la bsqueda: el elemento no est en el

rbol.
Si el valor del nodo raz es igual que el del elemento que buscamos,
terminamos la bsqueda con xito.
Si el valor del nodo raz es mayor que el elemento que buscamos,
continuaremos la bsqueda en el rbol izquierdo.
Si el valor del nodo raz es menor que el elemento que buscamos,
continuaremos la bsqueda en el rbol derecho.
PROGRAMACION II
20/08/2009
El valor de retorno de una funcin de bsqueda en un ABB puede ser un puntero al nodo encontrado, o NULL, si
no se ha encontrado.
INSERTAR UN ELEMENTO
Para insertar un elemento nos basamos en el algoritmo de bsqueda. Si el elemento est en el rbol no lo
insertaremos. Si no lo est, lo insertaremos a continuacin del ltimo nodo visitado.
Necesitamos un puntero auxiliar para conservar una referencia al padre del nodo raz actual. El valor inicial para
ese puntero es NULL.
Padre = NULL
nodo = Raiz
Bucle: mientras actual no sea un rbol vaco o hasta que se encuentre el
elemento.
o Si el valor del nodo raz es mayor que el elemento que buscamos,
continuaremos la bsqueda en el rbol izquierdo: Padre=nodo,
nodo=nodo->izquierdo.
o Si el valor del nodo raz es menor que el elemento que buscamos,
continuaremos la bsqueda en el rbol derecho: Padre=nodo,
nodo=nodo->derecho.
Si nodo no es NULL, el elemento est en el rbol, por lo tanto salimos.
Si Padre es NULL, el rbol estaba vaco, por lo tanto, el nuevo rbol slo
contendr el nuevo elemento, que ser la raz del rbol.
Si el elemento es menor que el Padre, entonces insertamos el nuevo
elemento como un nuevo rbol izquierdo de Padre.
Si el elemento es mayor que el Padre, entonces insertamos el nuevo
elemento como un nuevo rbol derecho de Padre.
Este modo de actuar asegura que el rbol sigue siendo ABB.

BORRAR UN ELEMENTO
Para borrar un elemento tambin nos basamos en el algoritmo de bsqueda. Si el elemento no est en el rbol no
lo podremos borrar. Si est, hay dos casos posibles:
1. Se trata de un nodo hoja: en ese caso lo borraremos directamente.
2. Se trata de un nodo rama: en ese caso no podemos eliminarlo, puesto que
perderamos todos los elementos del rbol de que el nodo actual es padre.
En su lugar buscamos el nodo ms a la izquierda del subrbol derecho, o el
ms a la derecha del subrbol izquierdo e intercambiamos sus valores. A
continuacin eliminamos el nodo hoja.
Necesitamos un puntero auxiliar para conservar una referencia al padre del nodo raz actual. El valor inicial para
ese puntero es NULL.
Padre = NULL
Si el rbol est vaco: el elemento no est en el rbol, por lo tanto salimos
sin eliminar ningn elemento.
PROGRAMACION II
20/08/2009
(1) Si el valor del nodo raz es igual que el del elemento que buscamos,
estamos ante uno de los siguientes casos:
o El nodo raz es un nodo hoja:
Si 'Padre' es NULL, el nodo raz es el nico del rbol, por
lo tanto el puntero al rbol debe ser NULL.
Si raz es la rama derecha de 'Padre', hacemos que esa
rama apunte a NULL.
Si raz es la rama izquierda de 'Padre', hacemos que esa
rama apunte a NULL.
Eliminamos el nodo, y salimos.
o El nodo no es un nodo hoja:
Buscamos el 'nodo' ms a la izquierda del rbol derecho
de raz o el ms a la derecha del rbol izquierdo. Hay que
tener en cuenta que puede que slo exista uno de esos
rboles. Al mismo tiempo, actualizamos 'Padre' para que
apunte al padre de 'nodo'.
Intercambiamos los elementos de los nodos raz y 'nodo'.
Borramos el nodo 'nodo'. Esto significa volver a (1), ya
que puede suceder que 'nodo' no sea un nodo hoja. (Ver
ejemplo 3)
Ejemplo 1: Borrar un nodo hoja

En el rbol de ejemplo, borrar el nodo 3.
1. Localizamos el nodo a borrar, al tiempo que mantenemos un puntero a
'Padre'.
2. Hacemos que el puntero de 'Padre' que apuntaba a 'nodo', ahora apunte a
NULL.
3. Borramos el 'nodo'.
Ejemplo 2: Borrar un nodo rama con intercambio de un nodo hoja.

En el rbol de ejemplo, borrar el nodo 4.
PROGRAMACION II
20/08/2009
1. Localizamos el nodo a borrar ('raz').

2. Buscamos el nodo ms a la derecha del rbol izquierdo de 'raz', en este
caso el 3, al tiempo que mantenemos un puntero a 'Padre' a 'nodo'.
3. Intercambiamos los elementos 3 y 4.
NULL.
Ejemplo 3: Borrar un nodo rama con intercambio de un nodo rama.

Para este ejemplo usaremos otro rbol. En ste borraremos el elemento 6.
1. Localizamos el nodo a borrar ('raz').

2. Buscamos el nodo ms a la izquierda del rbol derecho de 'raz', en este
caso el 12, ya que el rbol derecho no tiene nodos a su izquierda, si
optamos por la rama izquierda, estaremos en un caso anlogo. Al mismo
tiempo que mantenemos un puntero a 'Padre' a 'nodo'.
4. Ahora tenemos que repetir el bucle para el nodo 6 de nuevo, ya que no
podemos eliminarlo.
PROGRAMACION II
20/08/2009
5. Localizamos de nuevo el nodo a borrar ('raz').

6. Buscamos el nodo ms a la izquierda del rbol derecho de 'raz', en este
caso el 16, al mismo tiempo que mantenemos un puntero a 'Padre' a 'nodo'.
NULL.
Este modo de actuar asegura que el rbol sigue siendo ABB.

MOVIMIENTO A TRAVES DE UN RBOL
No hay mucho que contar. Nuestra estructura se referenciar siempre mediante un puntero al nodo Raiz, este
puntero no debe perderse nunca.
Para movernos a travs del rbol usaremos punteros auxiliares, de modo que desde cualquier puntero los
movimientos posibles sern: moverse al nodo raz de la rama izquierda, moverse al nodo raz de la rama derecha
o moverse al nodo Raiz del rbol.
INFORMACIN
Hay varios parmetros que podemos calcular o medir dentro de un rbol. Algunos de ellos nos darn idea de lo
eficientemente que est organizado o el modo en que funciona.
Comprobar si un rbol est vaco.
Un rbol est vaco si su raz es NULL.
PROGRAMACION II
20/08/2009
Calcular el nmero de nodos.

Tenemos dos opciones para hacer esto, una es llevar siempre la cuenta de nodos en el rbol al mismo tiempo que
se aaden o eliminan elementos. La otra es, sencillamente, contarlos.
Para contar los nodos podemos recurrir a cualquiera de los tres modos de recorrer el rbol: inorden, preorden o
postorden, como accin sencillamente incrementamos el contador.
Comprobar si el nodo es hoja.
Esto es muy sencillo, basta con comprobar si tanto el rbol izquierdo como el derecho estn vacos. Si ambos lo
estn, se trata de un nodo hoja.
Calcular la altura de un nodo.
No hay un modo directo de hacer esto, ya que no nos es posible recorrer el rbol en la direccin de la raz. De
modo que tendremos que recurrir a otra tcnica para calcular la altura.
Lo que haremos es buscar el elemento del nodo de que queremos averiguar la altura. Cada vez que avancemos
un nodo incrementamos la variable que contendr la altura del nodo.
Empezamos con el nodo raz apuntando a Raiz, y la 'Altura' igual a cero.

Si el valor del nodo raz es igual que el del elemento que buscamos,
terminamos la bsqueda y el valor de la altura es 'Altura'.
Incrementamos 'Altura'.
Calcular la altura de un rbol.

La altura del rbol es la altura del nodo de mayor altura. Para buscar este valor tendremos que recorrer todo el
rbol, de nuevo es indiferente el tipo de recorrido que hagamos, cada vez que cambiemos de nivel
incrementamos la variable que contiene la altura del nodo actual, cuando lleguemos a un nodo hoja
compararemos su altura con la variable que contiene la altura del rbol si es mayor, actualizamos la altura del
rbol.
Iniciamos un recorrido del rbol en postorden, con la variable de altura

igual a cero.
Cada vez que empecemos a recorrer una nueva rama, incrementamos la
altura para ese nodo.
Despus de procesar las dos ramas, verificamos si la altura del nodo es
mayor que la variable que almacena la altura actual del rbol, si es as,
actualizamos esa variable.
PROGRAMACION II
20/08/2009
EJEMPLO
Haremos ahora lo mismo que en el ejemplo en C, pero incluyendo todas las funciones y datos en una nica clase.
Declaracin de clase ArbolABB:
Declaramos dos clases, una para nodo y otra para ArbolABB, la clase nodo la declararemos como parte de la
clase ArbolABB, de modo que no tendremos que definir relaciones de amistad, y evitamos que otras clases o
funciones tengan acceso a los datos internos de nodo.
class ArbolABB {
private:
//// Clase local de Lista para Nodo de ArbolBinario:
class Nodo {
public:
// Constructor:
Nodo(const int dat, Nodo *izq=NULL, Nodo *der=NULL) :
dato(dat), izquierdo(izq), derecho(der) {}
// Miembros:
int dato;
Nodo *izquierdo;
Nodo *derecho;
};
// Punteros de la lista, para cabeza y nodo actual:
Nodo *raz;
Nodo *actual;
int contador;
int altura;
public:
// Constructor y destructor bsicos:
ArbolABB() : raz(NULL), actual(NULL) {}
~ArbolABB() { Podar(raz); }
// Insertar en rbol ordenado:
void Insertar(const int dat);
// Borrar un elemento del rbol:
void Borrar(const int dat);
// Funcin de bsqueda:
bool Buscar(const int dat);
// Comprobar si el rbol est vaco:
bool Vacio(Nodo *r) { return r==NULL; }
// Comprobar si es un nodo hoja:
bool EsHoja(Nodo *r) { return !r->derecho && !r->izquierdo; }
// Contar nmero de nodos:
const int NumeroNodos();
const int AlturaArbol();
// Calcular altura de un int:
int Altura(const int dat);
// Devolver referencia al int del nodo actual:
int &ValorActual() { return actual->dato; }
// Moverse al nodo raz:
PROGRAMACION II
20/08/2009
void Raiz() { actual = raz; }

// Aplicar una funcin a cada elemento del rbol:
void InOrden(void (*func)(int&) , Nodo *nodo=NULL, bool r=true);
void PreOrden(void (*func)(int&) , Nodo *nodo=NULL, bool r=true);
void PostOrden(void (*func)(int&) , Nodo *nodo=NULL, bool r=true);
private:
// Funciones auxiliares
void Podar(Nodo* &);
void auxContador(Nodo*);
void auxAltura(Nodo*, int);
};
Definicin de las funciones miembro:

Las definiciones de las funciones miembro de la clase no difieren demasiado de las que creamos en C. Tan solo
se han sustituido algunos punteros por referencias, y se usa el tipo bool cuando es aconsejable.
Por ejemplo, en las funciones de recorrido de rboles, la funcin invocada acepta ahora una referencia a un
entero, en lugar de un puntero a un entero.
EJEMPLO:
// Plantilla de Arbol Binario de Bsqueda en C++
// Octubre, 2006 - Maria Elena CEliberti
// C con Clase: http://c.conclase.net
#include <iostream>
using namespace std;
class ArbolABB {
private:
//// Clase local de Lista para Nodo de ArbolBinario:
class Nodo {
public:
// Constructor:
Nodo(const int dat, Nodo *izq=NULL, Nodo *der=NULL) :
dato(dat), izquierdo(izq), derecho(der) {}
// Miembros:
int dato;
Nodo *izquierdo;
Nodo *derecho;
};
// Punteros de la lista, para cabeza y nodo actual:
Nodo *raiz;
Nodo *actual;
int contador;
int altura;
public:
// Constructor y destructor bsicos:
ArbolABB() : raiz(NULL), actual(NULL) {}
~ArbolABB() { Podar(raiz); }
// Insertar en rbol ordenado:
PROGRAMACION II
20/08/2009
void Insertar(const int dat);

// Borrar un elemento del rbol:
void Borrar(const int dat);
// Funcin de bsqueda:
bool Buscar(const int dat);
// Comprobar si el rbol est vaco:
bool Vacio(Nodo *r) { return r==NULL; }
// Comprobar si es un nodo hoja:
bool EsHoja(Nodo *r) { return !r->derecho && !r->izquierdo; }
// Contar nmero de nodos:
const int NumeroNodos();
const int AlturaArbol();
// Calcular altura de un int:
int Altura(const int dat);
// Devolver referencia al int del nodo actual:
int &ValorActual() { return actual->dato; }
// Moverse al nodo raiz:
void Raiz() { actual = raiz; }
// Aplicar una funcin a cada elemento del rbol:
void InOrden(void (*func)(int&) , Nodo *nodo=NULL, bool r=true);
void PreOrden(void (*func)(int&) , Nodo *nodo=NULL, bool r=true);
void PostOrden(void (*func)(int&) , Nodo *nodo=NULL, bool r=true);
private:
// Funciones auxiliares
void Podar(Nodo* &);
void auxContador(Nodo*);
void auxAltura(Nodo*, int);
};
// Poda: borrar todos los nodos a partir de uno, incluido
void ArbolABB::Podar(Nodo* &nodo)
{
// Algoritmo recursivo, recorrido en postorden
if(nodo) {
Podar(nodo->izquierdo); // Podar izquierdo
Podar(nodo->derecho); // Podar derecho
delete nodo;
// Eliminar nodo
nodo = NULL;
}
}
// Insertar un int en el rbol ABB
void ArbolABB::Insertar(const int dat)
{
Nodo *padre = NULL;
actual = raiz;
// Buscar el int en el rbol, manteniendo un puntero al nodo padre
while(!Vacio(actual) && dat != actual->dato) {
padre = actual;
if(dat > actual->dato) actual = actual->derecho;
else if(dat < actual->dato) actual = actual->izquierdo;
}
// Si se ha encontrado el elemento, regresar sin insertar
if(!Vacio(actual)) return;
// Si padre es NULL, entonces el rbol estaba vaco, el nuevo nodo ser
// el nodo raiz
if(Vacio(padre)) raiz = new Nodo(dat);
PROGRAMACION II
20/08/2009
// Si el int es menor que el que contiene el nodo padre, lo insertamos

// en la rama izquierda
else if(dat < padre->dato) padre->izquierdo = new Nodo(dat);
// Si el int es mayor que el que contiene el nodo padre, lo insertamos
// en la rama derecha
else if(dat > padre->dato) padre->derecho = new Nodo(dat);
}
// Eliminar un elemento de un rbol ABB
void ArbolABB::Borrar(const int dat)
{
Nodo *padre = NULL;
Nodo *nodo;
int aux;
actual = raiz;
// Mientras sea posible que el valor est en el rbol
while(!Vacio(actual)) {
if(dat == actual->dato) { // Si el valor est en el nodo actual
if(EsHoja(actual)) { // Y si adems es un nodo hoja: lo borramos
if(padre) // Si tiene padre (no es el nodo raiz)
// Anulamos el puntero que le hace referencia
if(padre->derecho == actual) padre->derecho = NULL;
else if(padre->izquierdo == actual) padre->izquierdo = NULL;
delete actual; // Borrar el nodo
actual = NULL;
return;
}
else { // Si el valor est en el nodo actual, pero no es hoja
// Buscar nodo
padre = actual;
// Buscar nodo ms izquierdo de rama derecha
if(actual->derecho) {
nodo = actual->derecho;
while(nodo->izquierdo) {
padre = nodo;
nodo = nodo->izquierdo;
}
}
// O buscar nodo ms derecho de rama izquierda
else {
nodo = actual->izquierdo;
while(nodo->derecho) {
padre = nodo;
nodo = nodo->derecho;
}
}
// Intercambiar valores de no a borrar u nodo encontrado
// y continuar, cerrando el bucle. El nodo encontrado no tiene
// por qu ser un nodo hoja, cerrando el bucle nos aseguramos
// de que slo se eliminan nodos hoja.
aux = actual->dato;
actual->dato = nodo->dato;
nodo->dato = aux;
actual = nodo;
}
}
else { // Todava no hemos encontrado el valor, seguir buscndolo
padre = actual;
10
PROGRAMACION II
20/08/2009

}
}
}
// Recorrido de rbol en inorden, aplicamos la funcin func, que tiene
// el prototipo:
// void func(int&);
void ArbolABB::InOrden(void (*func)(int&) , Nodo *nodo, bool r)
{
if(r) nodo = raiz;
if(nodo->izquierdo) InOrden(func, nodo->izquierdo, false);
func(nodo->dato);
if(nodo->derecho) InOrden(func, nodo->derecho, false);
}
// Recorrido de rbol en preorden, aplicamos la funcin func, que tiene
// el prototipo:
// void func(int&);
void ArbolABB::PreOrden(void (*func)(int&), Nodo *nodo, bool r)
{
if(r) nodo = raiz;
func(nodo->dato);
if(nodo->izquierdo) PreOrden(func, nodo->izquierdo, false);
if(nodo->derecho) PreOrden(func, nodo->derecho, false);
}
// Recorrido de rbol en postorden, aplicamos la funcin func, que tiene
// el prototipo:
// void func(int&);
void ArbolABB::PostOrden(void (*func)(int&), Nodo *nodo, bool r)
{
if(r) nodo = raiz;
if(nodo->izquierdo) PostOrden(func, nodo->izquierdo, false);
if(nodo->derecho) PostOrden(func, nodo->derecho, false);
func(nodo->dato);
}
// Buscar un valor en el rbol
bool ArbolABB::Buscar(const int dat)
{
actual = raiz;
// Todava puede aparecer, ya que quedan nodos por mirar
if(dat == actual->dato) return true; // int encontrado
else if(dat > actual->dato) actual = actual->derecho; // Seguir
}
return false; // No est en rbol
}
// Calcular la altura del nodo que contiene el int dat
int ArbolABB::Altura(const int dat)
{
int altura = 0;
actual = raiz;
11
PROGRAMACION II
20/08/2009
// Todava puede aparecer, ya que quedan nodos por mirar

if(dat == actual->dato) return altura; // int encontrado
else {
altura++; // Incrementamos la altura, seguimos buscando
}
}
return -1; // No est en rbol
}
// Contar el nmero de nodos
const int ArbolABB::NumeroNodos()
{
contador = 0;
auxContador(raiz); // FUncin auxiliar
return contador;
}
// Funcin auxiliar para contar nodos. Funcin recursiva de recorrido en
// preorden, el proceso es aumentar el contador
void ArbolABB::auxContador(Nodo *nodo)
{
contador++; // Otro nodo
// Continuar recorrido
if(nodo->izquierdo) auxContador(nodo->izquierdo);
if(nodo->derecho) auxContador(nodo->derecho);
}
// Calcular la altura del rbol, que es la altura del nodo de mayor altura.
const int ArbolABB::AlturaArbol()
{
altura = 0;
auxAltura(raiz, 0); // Funcin auxiliar
return altura;
}
// Funcin auxiliar para calcular altura. Funcin recursiva de recorrido en
// postorden, el proceso es actualizar la altura slo en nodos hojas de mayor
// altura de la mxima actual
void ArbolABB::auxAltura(Nodo *nodo, int a)
{
// Recorrido postorden
if(nodo->izquierdo) auxAltura(nodo->izquierdo, a+1);
if(nodo->derecho) auxAltura(nodo->derecho, a+1);
// Proceso, si es un nodo hoja, y su altura es mayor que la actual del
// rbol, actualizamos la altura actual del rbol
if(EsHoja(nodo) && a > altura) altura = a;
}
// Funcin de prueba para recorridos del rbol
void Mostrar(int &d)
{
cout << d << ",";
}
12
PROGRAMACION II
20/08/2009
int main()
{
// Un rbol de enteros
ArbolABB ArbolInt;
// Insercin de nodos en rbol:
ArbolInt.Insertar(10);
cout << "Altura de arbol " << ArbolInt.AlturaArbol() << endl;
// Mostrar el rbol en tres ordenes distintos:
cout << "InOrden: ";
ArbolInt.InOrden(Mostrar);
cout << endl;
cout << "PreOrden: ";
ArbolInt.PreOrden(Mostrar);
cout << endl;
cout << "PostOrden: ";
ArbolInt.PostOrden(Mostrar);
cout << endl;
// Borraremos algunos elementos:
cout << "N nodos: " << ArbolInt.NumeroNodos() << endl;
ArbolInt.Borrar(5);
cout << "Borrar 5: ";
cout << endl;
ArbolInt.Borrar(8);
cout << endl;
ArbolInt.Borrar(15);
cout << endl;
cout << endl;
ArbolInt.Borrar(4);
13
PROGRAMACION II
20/08/2009
cout << endl;
cout << endl;
// Veamos algunos parmetros
cout << "N nodos: " << ArbolInt.NumeroNodos() << endl;
cout << "Altura de 1 " << ArbolInt.Altura(1) << endl;
cout << "Altura de 10 " << ArbolInt.Altura(10) << endl;
cout << "Altura de arbol " << ArbolInt.AlturaArbol() << endl;
cin.get();
return 0;
}
14

Arboles Binarios C 2

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Arboles Binarios C 2

Cargado por

Copyright:

Formatos disponibles

PROGRAMACION II

PROFESORA: MARIA ELENA CELIBERTI

ARBOL BINARIO DE BUSQUEDA

Si el rbol est vaco, terminamos la bsqueda: el elemento no est en el

Este modo de actuar asegura que el rbol sigue siendo ABB.

Ejemplo 1: Borrar un nodo hoja

Ejemplo 2: Borrar un nodo rama con intercambio de un nodo hoja.

1. Localizamos el nodo a borrar ('raz').

Ejemplo 3: Borrar un nodo rama con intercambio de un nodo rama.

1. Localizamos el nodo a borrar ('raz').

5. Localizamos de nuevo el nodo a borrar ('raz').

Este modo de actuar asegura que el rbol sigue siendo ABB.

Calcular el nmero de nodos.

Empezamos con el nodo raz apuntando a Raiz, y la 'Altura' igual a cero.

Calcular la altura de un rbol.

Iniciamos un recorrido del rbol en postorden, con la variable de altura

void Raiz() { actual = raz; }

Definicin de las funciones miembro:

void Insertar(const int dat);

// Si el int es menor que el que contiene el nodo padre, lo insertamos

if(dat > actual->dato) actual = actual->derecho;

// Todava puede aparecer, ya que quedan nodos por mirar

También podría gustarte