Árboles

Contenido:
• Definición de árbol
• Conceptos básicos
• Árboles binarios
• Recorrido de árboles
 Árboles

¿Qué es un árbol?

• Un árbol es una estructura de datos formada por nodos los

cuales están conectados por aristas.

A aristas
nodos

B D
C

E F
G H I
 Árboles

Conceptos Básicos

• Un árbol puede estar vacío; es decir no contener ningún nodo.

• Hablaremos entonces del Árbol Vacío.
• Raíz: es el nodo que está al tope del árbol. Un árbol solo tiene una
raíz.

Raiz
A

B C D

E F
G H I
 Árboles

Conceptos Básicos

• Camino: es la secuencia de nodos que hay que visitar para llegar

de un nodo a otro de un árbol.

Ejemplo: B-A-C-F es el camino entre B y F.

B C D

E F
G H I
 Árboles

Conceptos Básicos

• Un conjunto de nodos y aristas se define como un árbol si y solo si

existe un único camino desde la raiz hasta cada uno de sus nodos.

B C D

E F
Esto no es un arbol, G H I
porque existe mas
de un camino desde
la raiz para llegar a
algunos nodos
 Árboles

Conceptos Básicos

• Padre: En un árbol toda rama va de un nodo n1 a un nodo n2, se

dice que n1 es padre de n2.
Ejemplo: C es padre de E y de F, D es padre de G, de H y de I.

• Hijo: todo nodo puede tener mas de una arista que lo lleva a otro
nodo por debajo de él. Estos nodos que se encuentran por debajo de
un nodo dado se llaman hijos. Ejemplo: E es hijo de C, B es hijo de
A, H es hijo de D

A Padres

B C D
Hijos
E F I
G H
 Árboles

Conceptos Básicos

• Hojas: son aquellos nodos que no tienen hijos. En un arbol solo

puede haber una raíz pero pueden haber muchas hojas. Ejemplo:
B,E,F,G,H,I son hojas.

• Subárbol: Cualquier nodo se puede considerar como la raíz de un

subárbol.

A Subárbol

B C D

Hojas E F
G H I
 Árboles

Conceptos Básicos

• Visitar: se dice que un nodo es visitado cuando el control del

programa se detiene en él para hacer alguna operación tal como
acceder a su data, imprimir su data, modificar su data. Cuando
solamente se pasa por sobre un nodo no se considera una visita al
mismo.
• Recorrer .... Un árbol significa visitar todos sus nodos en un orden
específico.
Ejemplo: B-A-C-E-F-D-G-H-I
A

B C D

E F
G H I
 Árboles

Conceptos Básicos

• Nivel: el nivel de un nodo es el numero de generaciones que hay

desde la raiz hasta él.
El nivel de la raíz es cero.
• Profundidad o altura: es la longitud del camino mas largo desde la
raiz hasta una hoja.
La profundidad de este árbol es 2. La raiz tiene profundidad 0.

A Nivel 0

B C D Nivel 1

E F
G H Nivel
I 2
 Árboles

Árboles Binarios

• Se dice que un árbol es binario cuando cada nodo puede tener un

máximo de dos hijos.
• Los hijos de un nodo cualquiera se denotarán hijo derecho e hijo
izquierdo, de acuerdo a su posición en el gráfico del árbol.

Hijo Hijo
Izquierdo B E Derecho

C D
F G
 Árboles Binarios

Recorrido de Árboles Binarios

Un recorrido de un árbol binario requiere que cada nodo del árbol sea
procesado (visitado) una vez y sólo una en una secuencia predeterminada.
Enfoques generales para la secuencia de recorrido:

 Recorrido en profundidad, en el recorrido en profundidad, todos los

descendientes de un hijo se procesan antes del siguiente hijo.

 Recorrido en amplitud(anchura), en el recorrido en anchura, cada

nivel se procesa totalmente antes de que comience el siguiente nivel.
Este tipo de recorrido se denomina también recorridos por nivel. El
sentido del recorrido es de arriba abajo y de izquierda derecha.

12/06/2019
 Árboles Binarios
Recorrido en amplitud
RecorridoAmplitud
Algoritmo
Inicio
Insertar la raíz en cola Q;
Ptr = raiz
Mientras Q no vacía:
InitCola()
Extraer nodo n de Q;
AddCola(Ptr)
Insertar en Q los hijos de n; Mientras Not ColaVacia() hacer
ptr=SupCola()
3 Mostrar ptr^.inf
Camino 3 1 6 2 5 7 4 Si ptr^izq <> NULL entonces
AddCola(ptr^.izq)
1 6 Fin_si
Si ptr^der <> NULL entonces
2 5 7 AddCola(ptr^.der)
Fin_si
4 Fin_mientras
Fin.
12/06/2019
 Árboles Binarios
Recorrido en profundidad
Dado un árbol binario que consta de un nodo raíz (N), un subárbol izquierdo (I) y un
subárbol derecho (D) se pueden definir tres tipos de secuencia de recorrido en
profundidad.
Recorridos de árboles binarios

1 2 3

2 3 1 3 1 2

Subárbol Subárbol Subárbol Subárbol Subárbol Subárbol

izquierdo derecho izquierdo derecho izquierdo derecho

(a) Recorrido preorden (b) Recorrido en orden (c) Recorrido postorden

1° Padre 1° Hijo izquierdo 1° Hijo izquierdo

2° Hijo izquierdo 2° Padre 2° Hijo derecho
3° Hijo derecho 3° Hijo derecho 3° Padre

12/06/2019
 Árboles Binarios
Recorrido en profundidad

Según sea la estrategia a seguir, los recorridos se conocen como enorden (inorder) (orden
simétrico), preorden (preorder) (orden previo), y postorden (postorder) (orden posterior).

Preorden (nodo-izquierdo-derecho) (NID)

Enorden (izquierdo-nodo-derecho) (IND)
Postorden (izquierdo-derecho-nodo) (IDN)

Donde:
N = Nodo raíz
I = Subárbol izquierdo
D = Subárbol derecho

12/06/2019
 Árboles Binarios
- Recorrido preorden (NID)

Regla:
Se procesa el nodo raíz , subárboles izquierdo y derecho.

- Recorrido preorden (NID)

1. Recorrer el raíz (N).
2. Recorrer el subárbol izquierdo (I) en preorden.
3. Recorrer el subárbol derecho (D) en preorden.

A
Camino A, B, D, E, C, F, G
1

B C

2 5
D E F G

3 4 6 7
Recorrido preorden de un árbol binario

12/06/2019
 Árboles Binarios
- Recorrido preorden (NID)

Algoritmo Preorden (val raiz <puntero a nodos>)

inicio
si (raiz no es nulo)
Procesar(raiz)
Preorden(raiz->subarbolIzquierdo)
Preorden(raiz->subarbolDerecho)
retorno
fin Preorden

Función Preorden en C (el tipo de los datos es entero):

typedef int TipoElemento;
struct nodo {
TipoElemento datos;
struct nodo * hijo_izqdo, * hijo_dcho;
};
typedef struct nodo Nodo;
void Preorden (Nodo * p) {
if (p) {
printf(“%d ”, p->datos);
Preorden(p->hijo_izqdo);
Preorden(p->hijo_dcho);
}
12/06/2019 }
 Árboles Binarios
- Recorrido preorden (NID)

PreOrden
Inicio
InitPila()
AddPila( NULL)
Ptr = raiz
Mientras ptr <> NULL hacer
Mostrar ptr^.inf
Si ptr^der <> NULL entonces
AddPila( ptr^.der)
Fin_si
Si ptr^.izq <> NULL entonces
Ptr = ptr^.izq
Sino
Ptr = SupPila()
Fin_si
Fin_mientras
Fin.

12/06/2019
 Árboles Binarios
- Recorrido enorden (NID)
Regla:
Se procesa el nodo subárboles izquierdo, raiz y el subarbol derecho.
- Recorrido enorden (IND)

Si el árbol no está vacío, el método implica los siguientes pasos:

1. Recorrer el subárbol izquierdo (I) en inorden.
2. Visitar el nodo raíz (N).
3. Recorrer el subárbol derecho (D) en inorden.

- Recorrido enorden (IND)

4 Camino D, B, E, A, F, C, G

B C

2 6
D E F G

1 3 5 7

Recorrido enorden de un árbol binario

12/06/2019
 Árboles Binarios
- Recorrido enorden (IND)

Algoritmo Enorden (val raiz <puntero a nodos>)

inicio
si (raiz no es nulo)
Enorden(raiz->subarbolIzquierdo)
Procesar(raiz)
Enorden(raiz->subarbolDerecho)
retorno
fin Enorden

Función Enorden en C
void Enorden(Nodo * p) {
if (p) {
Enorden(p->hijo_izqdo); /* recorrer subárbol izquierdo */
printf (“%d “, p->datos); /* visitar la raíz */
Enorden(p->hijo_dcho); /* recorrer subárbol derecho */
}
}
12/06/2019
- Recorrido enorden (IND)
Árboles Binarios
InOrden
Inicio
InitPila()
AddPila(NULL)
Ptr = raiz
Mientras ptr <> NULL hacer
Mientras ptr <> NULL hacer
AddPila(ptr)
Ptr = ptr^.izq
Fin_mientras
Ptr = SupPila()
Tieneder =false
Mientras Ptr <> NULL y no tieneder hacer
Mostrar ptr ^.inf
Si ptr^.der <> NULL entonces
Ptr = ptr^.der
Tieneder = true
Sino
Ptr = SupPila()
Fin_si
Fin_mientras
Fin_mientras
Fin.

12/06/2019
 Árboles Binarios
- Recorrido postorden (IDN)
Regla:
Se procesa el nodo subárboles izquierdo, derecho y la raiz

- Recorrido postorden (IDN)

1. Recorrer el subárbol izquierdo (I) en postorden.
2. Recorrer el subárbol derecho (D) en postorden.
3. Visitar el nodo raíz (N).

- Recorrido postorden (IDN)

7 Camino D, E, B, F, G, C, A

B C

3 6
D E F G

1 2 4 5

Recorrido postorden de un árbol binario

12/06/2019
 Árboles Binarios
- Recorrido postorden (IDN)

Algoritmo Postorden (val raíz <puntero a nodos>)

inicio
si (raiz no es nulo)
Postorden(raiz->subarbolIzquierdo)
Postorden(raiz->subarbolDerecho)
Procesar(raiz)
retorno
fin Postorden

Función Postorden en C
void Postorden(Nodo * p) {
if (p) {
Postorden(p->hijo_izqdo);
Postorden(p->hijo_dcho);
printf(“%d ”, p->datos);
}
}
12/06/2019
Inicio
Cima = 1
Pila[cima]=NULL
Ptr = raiz
Mientras ptr <> NULL hacer
Mientras ptr <> NULL hacer
AddPila( ptr)
Si ptr^.der <> NULL entonces
AddPila(-ptr^.der)
Fin_si
Ptr = ptr^.izq
Fin_mientras
Ptr = SupPila()
Salir = false
Mientras ptr <> NULL y no salir hacer
Si prt > 0 entonces
Mostrar prt^.inf
Ptr = SuppPila()
Sino
Ptr = -ptr
Salir=true
Fin_si
Fin_mientras
Fin_mientras
Fin.

12/06/2019