Estructuras de datos no lineales

rboles Estructuras de datos jerrquicas

rbol T1

*REPASAR RECURSIVIDAD*
Directorio raz /
home

usr

rosa
www

alumnos

f1

jags

bin

docs

papers

var

include

b1.txt

f2
d1

d2

Un rbol se compone de nodos {Raz: no tiene padre, Hoja: no tienen hijos, Interiores: el resto de
nodos}
rbol Es un grafo acclico donde cada nodo tiene grado de entrada 1 excepto el nodo raz que
tiene grado de entrada 0. Y el grado de salida de cada nodo es 0 o mayor que 0.
rbol n-ario Todos los nodos tienen 0 n-hijos. Si tiene hijos, tiene n-hijos.
Un rbol 2-ario tiene o 0 hijos o 2 hijos.
Un rbol binario tiene 0, 1 o 2 hijos.
Camino en un rbol
Es una sucesin de nodos n1,n2,...nk como se ponen subindices
donde el nodo i-simo (ni) es padre del nodo i+1 (ni+1).
La longitud del camino es igual al n de nodos -1.
/home/rosa/alumnos/f1
Padre de rosa
Ancestro: El nodo ni es ancestro del nodo nj si existe un camino desde ni tal que ni se coloca en el
camino delante de nj.
nj es descendiente de ni si existe un camino tal que nj se lista despus de ni.
Subrbol: Sea ni y todos los descendientes de ni en el rbol T1.

Altura de un nodo ni: Se define como el camino ms largo entre el nodo ni y una hoja. La altura del
rbol es igual a la altura del nodo raz.
La altura de / es 4, home 3, rosa 2, alumnos 1 y f1 0.
Todos los nodos hoja tienen altura 0.
Profundidad de un nodo: La longitud del camino que existe entre el nodo y la raz.
La profundidad de / es 0, usr 1, include 2.
Niveles: Si un rbol tiene altura h, tenemos h+1 niveles. El rango de valores para los niveles va
desde 0 hasta h.
0 = raz
1 = hijos de la raz
h: solamente hojas
i = tenemos todos los nodos de profundidad i
Grado de un nodo: (grado de salida) Es el nmero de hijos que tiene un nodo.
Grado de un rbol: Mximo de los grados de los nodos del rbol.
rbol binario: Cada nodo puede tener 0, 1 o 2 hijos.
rbol binario homogneo: Cada nodo tiene 0 o 2 hijos.
rbol binario completo: Cada nodo tiene todos los niveles completos excepto el ltimo. Los huecos
quedan a la derecha.

rbol no homogneo
ni completo

2^i = 2^0 + 2^1 + + 2^h (desde i=0 hasta h)

2Sn = 2^1 + + 2^(h+1)
_________________________________________
Sn + 2^(h+1) 2^0 = 2^(h+1) -1

rbol homogneo
completo

- Profundidad

Preorden
Inorden
Postorden

Recorridos
- Anchura

Preorden Raz, Pre(T1), Pre(T2), , Pre(Tn) Se aplica recursivamente

Pre(home) home
Pre(rosa) rosa
Pre(docs) docs
Pre(alumnos) alumnos
Pre(d1) d1
Pre(d2) d2
Pre(f1) f1
Pre(f2) f2
Se hace preorden del nodo, se lista el nodo, y cuando se llega a la hoja se vuelve al nivel
superior, hasta que se listan todos los nodos del rbol.
A

i
Preorden: raz Pre(T1) Pre(T2) Pre(Tn)
Pre(a)
a Pre(b)
Pre(c)
b Pre(e)
Pre(f)
e
f

Pre(h)
h Pre(i)
i

Inorden: In(T1) raz In(T2) In(Tn)

In(a)
a

In(c)

In(b)
In(e)

In(d)

In(g) c

In(h)

In(i)

d
h

In(f)
i

e
e

f
b

Pre(d)
d

Postorden: Post(T1) Post(T2) Post(Tn) raz

Post(a)
Post(b)

Post(c)

Post(e)

Post(f)

Post(d)

Post(g)

Post(h)

Post(i)

i
e

Recorrido en anchura a

c
h
i
e

f
f
f
f

h
i
g
g

i
c
c
h

g
g
a
i

AB (rbol binario)
Preorden: raz Pre(Tj) Pre(Td)
Inorden: In(Ti) raz In(Td)
Postorden: Post(Ti) Post(Td) raz
a
b

d
e

h
Preorden: a
Inorden: d
Postorden: d
Por niveles: a

b
b
e
b

i
d
e
b
c

e
a
h
d

r
x
n
v

Inorden: v

Rotacin a la izquierda:
s
r

x
w
v

u
z

El inorden es el mismo que en el rbol de antes (inorden unvoco). Para que distinguir los
rboles nos tendran que dar mnimo un inorden y un preorden.
Las rotaciones sirven para obtener AVL (rboles binarios equilibrados), para obtener los
mnimos tiempos de ejecucin. El objetivo es conseguir una eficiencia T(n) = log n(base 10).
(n hijo a la izquierda de m)
Pre(n) < Pre(m) n aparece antes que m
Pre(n) < Pre(m)

In(n) < In(m)

Post(n) < Post(m)

hizq

Falso

Verdadero

Verdadero

hdrch

Falso

Falso

Verdadero

desc

Falso

(Dep si dcha o izda)

Verdadero

anc

Verdadero

(Dep si dcha o izda)

Falso

Preorden: g
Inorden: i

e
a

a
b

i
e

b
g

m
l

c
d

l
c

Ti

Td

Si es un rbol binario...
g
e
a
i

m
c

Lectura y escritura de un rbol en disco

1
4

6
8

k
f

d
f

j
h

f
m

k
k

j h
h j

Se coloca un carcter donde no hay hijos

Preorden: n1 n2 n4 x x n5 x n8 x x n3 n6 x x n7 x x
rboles binarios(AB)
1) Son rboles tal que cada nodo tiene 0, 1 o 2 hijos
2) l rbol vaco es un AB
Representacin:
template <class T>
struct info_nodo{
info_nodo *padre, *hizq, *hder;
T et;
info_nodo(){
padre=hizq=hder=0;
}
info_nodo(const T& e){
et = e;
padre=hizq=hder=0;
}
};
5
3

50XX
3XX0
2X00

7XXX
0X00

8X00

- Get: Padre, Hi, Hd, etiqueta.

- Insertar: Hi, Hd.
- Podar: Hi, Hd. (Cortar toda la rama)
- Recorrido: Preorden, Inorden, Postorden, Par Nodos
- Leer/Escribir (flujos)
- Copiar un rbol en otro
- Borrar todo el rbol
- Size
- Iguales
(Utilizamos memoria dinmica, vamos a necesitar constructor de copia, destructor y
operador de asignacin).

template <class T>

info_nodo <T> * getPadre(info_nodo<T> * n){
return n->padre;
}
template <class T>
info_nodo <T> * getHi(info_nodo <T> *n){
return n->hizq;
}
template <class T>
info_nodo <T> * getHd)info_nodo <T> *n){
return n->hder;
}

template <class T>

void Copiar(info_nodo <T> *s, info_nodo <T> * & d){
if(s==0){
d=0;
}
else{
d = new info_nodo <T> (s->et);
Copiar(s->hi, d->hizq);
Copiar(s->hder, d->hder);
if(d->hizq!=0)
d->hizq->padre=d;
if(d->hder!=0)
d->hder->padre=d;
}
}
template <class T>
void BorrarInfo(info_nodo <T> *n){
if(n!=0){
BorrarInfo(n->hizq);
BorrarInfo(n->hder);
delete n;
}
}
template <class T>
void InsertarHijoIzquierda(info_nodo <T> *n, info_nodo <T> *sub){
//Borrar hijo a la izquierda de n
//Poner sub como hijo a la izquierda de n
info_nodo <T> * aux = n->hizq;
if(sub!=0){
n->hizq=sub;
BorrarInfo(aux);
n->hizq->padre=n;
}
else{
n->hizq=0;
BorrarInfo(aux);
}
}
*AADIR INSERTARHIJODERECHA*

Otra versin de InsertarHijoIzquierda

template <class T>
void InsertarHijoIzquierda(info_nodo <T> *n, const T &v){
info_nodo <T> *aux = new info_nodo(v);
InsertarHijoIzquierda(n, aux);
}
template <class T>
void PodarHijoIzquierda(info_nodo <T> *n){
if(n->hizq!=0){
BorrarInfo(n->hizq);
n->hizq=0;
}
}
*IMPLEMENTAR PODAR HIJO A LA DERECHA*
template <class T>
info_nodo <T> *Podar_HijoIzq_GetSubtree(info_nodo <T> *n){
info_nodo <T> * aux = n->hizq;
n->hizq=0;
aux->padre=0;
return aux;
}
//Quedan unas cuantas funciones