Leccin 10:

rboles
rboles
rboles binarios
Recorridos
rboles binarios de bsqueda
Insercin y borrado en los ABB
Consideraciones finales

Motivacin
Mymail es una nueva compaa que ofrece cuentas de
correo electrnico a sus usuarios. Al cabo de varias semanas
ya cuenta con miles de usuarios, y a este ritmo se esperan
que sean millones. Cmo manejamos dicha cuentas de
modo eficiente?

...

maripili@
piluca@
mymail.com mymail.com

lucasin@
josefo@
mymail.com mymail.com

nachete@
mymail.com

...

Los vectores no son eficientes:

Si estn ordenados cuesta O(n) insertar nuevas cuentas.
Si no estn ordenados cuesta O(n) buscar un alias.
Leccin 10: rboles

Motivacin

Las estructuras de datos estudiadas hasta el momento

son EEDD lineales con acceso directo o secuencial.
Para este problema se necesita una estructura de datos
de acceso por clave o contenedor asociativo que
permita bsquedas ecientes.
Por ejemplo, para que la bsqueda sea logartmica (en
base 2), en cada paso debemos descartar la mitad de los
datos
pendientes de procesar, como lo hace la
bsqueda dicotmica.
Algunos
rboles
funcionan
como
contenedores
asociativos que permiten resolver la bsqueda de forma
eciente.
Leccin 10: rboles

Definiciones
Un rbol es una jerarqua de nodos enlazados que
cumple:

Cada nodo tiene cero o ms hijos

Cada nodo tiene como como mximo un padre.

A es el padre de D
H es el hijo de D
H no tiene hijos
A no tiene padre

Leccin 10: rboles

Definiciones

El nodo del rbol que no tiene padre es la raz

Los nodos que no tienen hijos son hojas

raz

A es el nodo raz
H es una hoja

altura

hoja

Leccin 10: rboles

Definiciones

La altura del rbol es el camino ms largo que se

recorre desde la raz hasta una hoja.
La altura de un nodo es la longitud del camino
ms largo de dicho nodo a una hoja.
La profundidad de un nodo es la longitud del
camino desde la raz a dicho nodo.

La altura del rbol es 3

La altura del nodo E es 2
La altura del nodo F es 0
La profundidad de J es 2

altura

Leccin 10: rboles

Aplicaciones
Los
rboles
son
una
estructura
de
datos
extremadamente verstil que permite representar:

Genealogas u organigramas,

Circuitos elctricos,

Estructuras de directorios, o frmulas matemticas

Y por supuesto contenedores asociativos

(a+b)*(c-d)

Leccin 10: rboles

rboles binarios

El orden de un rbol es el mximo nmero de

nodos que puede tener un nodo.
Un rbol binario tiene orden 2.
Los rboles binarios son los ms utilizados como
contenedores de datos en memoria.
raiz

Ejemplo:

G
D

subrbol izquierdo

T
K

subrbol derecho
A
Leccin 10: rboles

L
U

Definiendo rboles binarios en

C++
template
template <class
<class T>
T>
class
Nodo
class Nodo
{{
Nodo<T>
Nodo<T> *izq;
*izq;
Nodo<T>
*der;
Nodo<T> *der;
TT dato;
dato;
public:
public:
Nodo():
Nodo(): izq(0),
izq(0), der(0){}
der(0){}
Nodo(T
&ele):
izq(0),
Nodo(T &ele): izq(0), der(0),
der(0), dato(ele){}
dato(ele){}
};
};

izq

dato der

...

...

La denicin de nodo es recursiva

template
template <class
<class T>
T>
class
Abb
{
class Abb {
Nodo<T>
Nodo<T> *raiz;
*raiz;
public:
public:
Abb();
Abb();
...
...
};
};

Un rbol es un puntero a un nodo, el nodo raz

Leccin 10: rboles

Recorridos de rboles

El mecanismo para acceder a los datos de un rbol

se parece al de la lista enlazada: de un nodo padre
se pasa a un nodo hijo (el izquierdo o derecho).
Pero no al revs, desde un nodo hijo no tenemos
acceso al nodo padre.
Los mtodos ms simples de recorrido son los
siguientes mtodos recursivos: preorden, inorden
y postorden.
M
G
D

T
K
Leccin 10: rboles

10

Recorridos: preorden
En Preorden el orden de visita es:

1. Nodo raz
2. Nodo izquierda (recursivo)

3. Nodo derecha (recursivo)

M
H
D
A

T
K

R
V

L
U

template
template <class
<class T>
T>
void
void Abb<T>::preorden
Abb<T>::preorden (Nodo<T>
(Nodo<T> *p,
*p, int
int nivel){
nivel){
if
if (p){
(p){
//
// Sustituir
Sustituir por
por procesamiento
procesamiento ----cout
cout <<
<< "Procesando
"Procesando nodo
nodo "<<
"<< p->dato
p->dato ;;
cout
W
cout <<
<< "en
"en el
el nivel
nivel "" <<
<< nivel
nivel <<
<< endl;
endl;
//
// --------------------preorden
preorden (p->izq,
(p->izq, nivel+1);
nivel+1);
preorden
preorden (p->der,
(p->der, nivel+1);
nivel+1);
}}
}}

MHDAGKLTRVUW

Leccin 10: rboles

11

Recorridos: inorden
En Inorden orden de visita es:

1. Nodo izquierda (recursivo)

2. Nodo raz

3. Nodo derecha (recursivo)

M
H
D
A

T
K

R
V

L
U

template
template <class
<class T>
T>
void
Abb<T>::inorden
void Abb<T>::inorden (Nodo<T>
(Nodo<T> *p,
*p, int
int nivel){
nivel){
if
(p){
if (p){
inorden
inorden (p->izq,
(p->izq, nivel+1);
nivel+1);
//
Sustituir
por
procesamiento
// Sustituir por procesamiento ------W
cout
<<
"Procesando
nodo
"
<<
p->dato;
cout << "Procesando nodo " << p->dato;
cout
cout <<
<< "en
"en el
el nivel
nivel "" <<
<< nivel
nivel <<
<< endl;
endl;
//
----------// ----------inorden
inorden (p->der,
(p->der, nivel+1);
nivel+1);
}}
}}

ADGHKLMRUVTW

Leccin 10: rboles

12

Recorridos: postorden
En Inorden el orden de visita es:

1. Nodo izquierda (recursivo)

2. Nodo derecha (recursivo)

3. Nodo raz
M
H
D
A

T
K

R
V

L
U

template
template <class
<class T>
T>
void
Abb<T>::postorden
void Abb<T>::postorden (Nodo<T>
(Nodo<T> *p,
*p, int
int nivel){
nivel){
if
(p){
if (p){
postorden
postorden (p->izq,
(p->izq, nivel+1);
nivel+1);
postorden
(p->der,
nivel+1);
W
postorden (p->der, nivel+1);
//
// Sustituir
Sustituir por
por procesamiento
procesamiento ------cout
<<
"Procesando
nodo
"<<
p->dato;
cout << "Procesando nodo "<< p->dato;
cout
cout <<
<< "en
"en el
el nivel
nivel "" <<
<< nivel
nivel <<
<< endl;
endl;
//
----------// ----------}}
}}

A G D L K H U V R W T M Leccin 10: rboles

13

Recorridos

Las funciones anteriores preorden(), inorden() y

postorden() son recursivas, y deben ser privadas.
Otras funciones pblicas deben invocarlas.
Existen versiones iterativas para
recorridos, pero son ms complejas.

realizar

los

template
template <class
<class T>
T>
class
Abb
{
class Abb {
Nodo<T>
Nodo<T> *raiz;
*raiz;
void
preorden(Nodo<T>
void preorden(Nodo<T> *p,
*p, int
int nivel);
nivel);
void
inorden(Nodo<T>
*p,
int
nivel);
void inorden(Nodo<T> *p, int nivel);
void
void postorden(Nodo<T>
postorden(Nodo<T> *p,
*p, int
int nivel);
nivel);
public:
public:
Abb(void);
Abb(void);
void
void recorrePreorden()
recorrePreorden() {{ preorden(raiz,0);
preorden(raiz,0); }}
void
void recorreInorden()
recorreInorden() {{ inorden(raiz,0);
inorden(raiz,0); }}
void
void recorrePostorden()
recorrePostorden() {{ postorden(raiz,0);
postorden(raiz,0); }}

}}
Leccin 10: rboles

14

rboles binarios de bsqueda

En un rbol binario de bsqueda se debe cumplir la
siguiente regla:

Para cada nodo x, todas las claves en el subrbol

izquierdo TL deben ser menores que el valor de x, y
todas las claves del subrbol derecho TR deben ser
mayores que el valor de x.
15
8

5
2

19
9

16

20
18

11
17

Leccin 10: rboles

15

Bsqueda en los ABB

Los rboles binarios de bsqueda (ABB) son
interesantes porque agilizan la bsqueda del dato q:

Si q es igual al dato en la raz encontrado

Si q menor que el dato en la raz continuar por subrbol
izquierdo
Si q es mayor que el dato en la raz continuar por subrbol
derecho
15
8
5
2

19
9

16

20
18

11
17

Buscamos el 17:
17 > 15 derecha
17 < 19 izquierda
17 > 16 derecha
17 < 18 izquierda
17 == 17 encontrado

Leccin 10: rboles

16

Bsqueda en los ABB

Si un rbol est equilibrado la bsqueda es O(logn)

template
template <class
<class T>
T>
Nodo<T>
*Abb<T>::buscaClave
Nodo<T> *Abb<T>::buscaClave (T
(T &ele,
&ele, Nodo<T>
Nodo<T> *p){
*p){
if
(!p)
if (!p)
return
return 0;
0;
else
if
(ele
else if (ele << p->dato)
p->dato)
return
buscaClave
return buscaClave (ele,
(ele, p->izq);
p->izq);
Funcin privada
else
if
(ele
>
p->
dato)
else if (ele > p-> dato)
return
return buscaClave
buscaClave (ele,
(ele, p->der);
p->der);
else
return
p;
else return p;
}}
template
template <class
<class T>
T>
bool
Abb<T>::buscar
bool Abb<T>::buscar (T
(T &ele,
&ele, TT &result){
&result){
Nodo<T>
*p
=
buscaClave
(ele,
Nodo<T> *p = buscaClave (ele, raiz);
raiz);
if
(p)
{
if (p) {
result
result == p->dato;
p->dato;
return
true;
return true;
}}
return
return false;
false;
}}
Leccin 10: rboles

Funcin pblica

17

Insertar en un ABB

Un nuevo nodo siempre queda ubicado en una

hoja.
El orden de insercin determina la forma del rbol
rboles equivalentes

15

15

8
5
2

19
9

16

20
18

11

16

6
5
2

17

18

9
8

11

20

17
19

Leccin 10: rboles

18

Insertar en un ABB
Este cdigo asume que no se repiten claves
template
template <class
<class T>
T>
Nodo<T>
*Abb<T>::insertaDato(T
Nodo<T> *Abb<T>::insertaDato(T &ele,
&ele, Nodo<T>*
Nodo<T>* &p){
&p){
if
(!p){
if (!p){
pp == new
new Nodo<T>(ele);
Nodo<T>(ele);
}} else
{
else {
if
if (ele
(ele <=
<= p->dato)
p->dato)
p->izq
=
p->izq = insertaDato(ele,
insertaDato(ele, p->izq);
p->izq);
else
Funcin privada
else
p->der
=
insertaDato(ele,
p->der);
p->der = insertaDato(ele, p->der);
}}
return
return p;
p;
}}
template
template <class
<class T>
T>
bool
Abb<T>::insertar(T
bool Abb<T>::insertar(T &ele){
&ele){
bool
encontrado
=
buscar(ele);
bool encontrado = buscar(ele);
if
if (!encontrado){
(!encontrado){
insertaDato(ele,
insertaDato(ele, raiz);
raiz);
return
true;
return true;
}}
return
return false;
false;
}}
Leccin 10: rboles

Funcin pblica

19

Borrar un nodo de un ABB

Depende del nmero de hijos:

Si es una hoja: se elimina directamente el nodo

15

15
8
5

19

19
9

Si el nodo e tiene slo un hijo h: se engancha el

padre de e con h
15
15
18

6
6
5

16
5

18

9
17

20

Leccin 10: rboles

17

20
20

Borrar un nodo de un ABB

Si el nodo e tiene dos hijos:

Encontrar f, el mnimo elemento en el subrbol

derecho (f es una hoja)
Colocar f en la posicin de e y luego eliminar f
15
8

19
9

Colocamos 20

15

16

Borrar 19
5

21
20

22

Mnimo elemento del

Subrbol derecho

20
9

16

21
20

22

Se elimina el nodo 20
Leccin 10: rboles

21

Borrar un nodo de un ABB

template
template <class
<class T>
T>
Funcin pblica
bool
bool Abb<T>::eliminar(T
Abb<T>::eliminar(T &ele){
&ele){
Nodo<T>
Nodo<T> *result
*result == borraDato(ele,
borraDato(ele, raiz);
raiz);
if
if (result)
(result) return
return true;
true;
return
return false;
false;
}}
Funcin que encuentra el mnimo
de un subrbol y lo deja aislado apuntado
por result
template
template <class
<class T>
T>
Nodo<T>
Nodo<T> *Abb<T>::borraMin(Nodo<T>*
*Abb<T>::borraMin(Nodo<T>* &p){
&p){
Nodo<T>
*result;
Nodo<T> *result;
if
if (p){
(p){
if
if (p->izq)
(p->izq)
15
return
return borraMin(p->izq);
borraMin(p->izq);
p
else
else {{
result
result == p;
p;
25
6
pp == p->der;
p->der;
p
return
return result;
result;
}}
27
5
17
9
}}
}}

menor=result
Leccin 10: rboles

20

22
23

22

Borrar un nodo de un ABB

template<class
template<class T>
T>
Nodo<T>
*Abb<T>::borraDato(T
Nodo<T> *Abb<T>::borraDato(T &ele,
&ele, Nodo<T>*
Nodo<T>* &p){
&p){
Funcin privada
if
(p)
{
if (p) {
este cdigo hay que arreglarlo porque es un desastre
if
if (ele
(ele << p->dato)
p->dato)
borraDato(ele,
borraDato(ele, p->izq);
p->izq);
else
else
if
if (ele
(ele >> p->dato)
p->dato)
borraDato(ele,
borraDato(ele, p->der);
p->der);
else
{
//encontrado
else {
//encontrado
Nodo<T>
*temp
Nodo<T> *temp == p;
p;
if
(!p->izq)
//tiene
if (!p->izq) //tiene hijo
hijo aa la
la decha
decha
pp == p->der;
p->der;
else
else
if
if (!p->der)
(!p->der) //tiene
//tiene hijo
hijo aa la
la izda
izda
pp == p->izq;
p->izq;
else
if
(p->izq
else if (p->izq &&
&& p->der){
p->der){ //tiene
//tiene ambos
ambos hijos
hijos
temp
=
borraMin(p->der);
temp = borraMin(p->der);
p->dato
p->dato == temp->dato;
temp->dato;
}}
delete
delete temp;
temp; //borrar
//borrar en
en todos
todos los
los casos
casos (tambin
(tambin hoja)
hoja)
temp
=
0;
temp = 0;
}}
}}
return
return p;
p;
}}
Leccin 10: rboles

23

Consideraciones finales
Los ABB mejoran el tiempo de bsqueda pero:

En el peor de los casos la bsqueda es lineal.

Tan slo se consigue tiempo logartmico esperado

La estructura es muy dependiente del orden de

entrada de los datos.
3

12

12

12

3
7

12

(a)

(b)

Leccin 10: rboles

(c)

(d)

24

Consideraciones finales
La solucin a estos problemas pasa por conseguir que
el rbol permanezca equilibrado tras las inserciones y
borrados

Un arbol es equilibrado si para cada nodo, el

nmero de niveles de sus subrboles izquierdo y
derecho no diere en ms de una unidad.
Las bsquedas en estos casos s son O(nlogn).
15
25

6
5

22
20

23

9
27

17

17

equilibrado

6
5

23

Leccin 10: rboles

15

20

25
27
25