Árboles estructura

ARBOLES
Un árbol es una estructura de datos compuesta por un conjunto de nodos, dispuestos en
forma jerárquica. Cada nodo puede tener, varios apuntadores a otros nodos llamados
hijos, pero ser apuntado por uno solo, llamado Padre. Uno de ellos no tiene padre y se
conoce como la Raíz, que además, es el punto de acceso al árbol.
Ejemplo de cómo se representa un árbol.
Algunas Definiciones.
El Grado de un nodo. Se refiere al número de hijos de cada nodo. Por ejemplo
Grado (A) = 5
Grado (H) = 4
Grado (N) = 1
Grado del árbol. Corresponde al máximo grado entre los grados de sus nodos. Para el
ejemplo el grado del árbol es 5.
Los niveles, corresponden al número de arcos que existen desde la raíz al nodo
requerido. En el ejemplo el nivel del nodo A es cero, el nivel del nodo Q es 3.
La altura del árbol corresponde al máximo nivel, para el árbol ejemplo la altura es 4.
Los hijos de A son B, C, D, E, F
El padre de H, es B
El tío de G es C.
El primo de J es G,H,I
Los vecinos de M son N, O, P, Q, R
Los nodos que no tienen hijos se conocen con el nombre de nodos terminales u hojas.
Para representar un árbol se debe establecer el grado del árbol y de acuerdo con eso se
determina el número de apuntadores de cada nodo.
Nivel 0
Nivel 1
Nivel 2
Nivel 3
Nivel 4
RAIZ
Observe, el nodo A, corresponde a la
raíz. Su padre es Nulo y tiene los
nodos B, C, D, E, y F como hijos.
El Padre del nodo H es B y sus hijos
son: M, N, O, P.

Los arboles de grado mayor a dos se denominan árboles N-arios.
En este curso se trabajaran los arboles binarios y debes investigar el algoritmo para
convertir un árbol N-ario a Binario.
Arboles Binarios
Un árbol binario es una estructura homogénea, resultado de la concatenación de un
elemento llamado raíz, con dos subárboles binarios, llamados subárbol izquierdo y
subárbol derecho, que pueden ser nulos. Cada subárbol que no es nulo, a su vez es un
árbol que puede tener raíz, subárbol izquierdo y subárbol derecho y así sucesivamente.
Por lo tanto el concepto de árbol es recursivo.
Representación de los árboles binarios.
Las listas lineales se caracterizan porque cada nodo puede tener un solo nodo anterior y
un solo nodo sucesor.
En los arboles cada nodo puede tener varios sucesores y un solo anterior, razón por la
cual estos pueden representarse por listas medio de Listas No Lineales, cuyos nodos
pueden tener varios sucesores y varios anteriores. En este texto se trataran solamente los
A
B
D E
C
F
HG I
J
Hijo der
Hijo izq
Hijo Izq
Hijo Izq Hijo der
Hijo Izq
Hijo der
Raíz

arboles binarios que máximo pueden tener dos nodos sucesores (El hijo izquierdo y/o el
hijo derecho) y un solo nodo anterior (Su padre).
Una forma de representar un árbol Binario es mediante una Lista Enlazada No Lineal,
así:
1) Cada nodo puede tener varios campos para la información y dos campos
adicionales; uno para el apuntador al hijo izquierdo y otro para el apuntador al
hijo derecho. El campo de la información pueden estar compuesto de uno o
varios campos como sucede con los nodos de las Listas Enlazadas.
2) Una lista para representar un árbol podría ser como la de la figura el nodo donde
se inicia el árbol lo llamaremos la Raíz y este no tiene padre.
ALGORITMOS PARA RECORRIDO DE ARBOLES BINARIOS
Antes de conocer el algoritmo para crear un árbol binario, vamos a entender cómo se
realiza la búsqueda de información, pues ya no es en forma secuencial, como lo
hicimos con las listas tratadas en los capítulos anteriores sino a través de diferentes
recorridos. Entre los más conocidos están:
El recorrido en Preorden
El recorrido en Inorden
A
B
H
E F
C
A
G
A
I
Raiz
Cuál es la diferencia entre una lista doblemente enlazada y
un lista que se utilice para representar un árbol binario????
Apuntador al
hijo izquierdo
Apuntador al
hijo derecho
Campos para la
información

El recorrido en Postorden
El recorrido por Niveles.
La mayoría de los algoritmos de árboles utilizan Pilas y/o Colas, como estructuras
auxiliares para almacenar las direcciones de la lista que representa el árbol.
Es importante aclarar que para realizar cualquier operación sobre un árbol, es necesario
primero crearlo.
RECORRIDO PREORDEN.
El recorrido en Preorden consiste en escribir la Raíz del árbol, moverse al hijo
Izquierdo, escribir su información y luego moverse al hijo derecho y escribir su
información.
Cuando el árbol es más grande se deben seguir los siguientes pasos:
1) Nos ubicamos en la raíz del árbol principal y escribimos su información
2) Nos movemos al subárbol izquierdo del árbol principal, si existe, se recorre el
subárbol Izquierdo en Preorden; es decir, se escribe su raíz, si este tiene subárbol
izquierdo nos movemos a este nodo y recorremos en Preorden este subárbol
izquierdo hasta que no hayan más subárboles izquierdos.
3) Nos regresamos al último subárbol izquierdo y movemos a su respectivo hijo
derecho, si existe, escribimos su información y seguimos recorriéndolo en
Preorden.
4) El proceso anterior se repite hasta cuando pasemos por todos los nodos de la
lista.
El algoritmo puede utilizar recursividad o no. Analicemos primero la solución sin
hacer uso de la recursividad con el árbol de la figura.
A
B
K
D
H
E
G
J
C
I
F
Se utilizara una pila en la que se guardara inicialmente la dirección
del nodo Raíz.
DIR(K)
DIR(G), DIR(H),
DIR(D)
DIR(B)
Dir(A)
Pila
Escribe A y como este nodo es diferente de Nulo, nos movemos al
hijo izquierdo (B), escribe esta información y guardamos su
dirección en la pila, continuamos, moviéndoos al hijo izquierdo de B,
que es D, escribimos D, guardamos su dirección en la pila y
continuamos hasta que no haya más hijos izquierdo (Nulo).
Luego saca de la Pila y continuamos moviéndonos a la derecha, si
este elemento es diferente de Nulo, se escribe se guarda en la pila y
se continúa moviendo a los hijos izquierdos hasta que sea nulo, se
saca de la pila y se mueve hacia el hizo derecho del nodo sacado.
El algoritmo repite esteproceso hastacuando se llega a Nulo y la
pila quede vacía.
A
C
Preorden
AC
Preorden
ABC
A
B
A
C
A
B
Preorden
BA

SUB Preorden (raíz)
Tope ←0 // Pila vacía
P ←raíz //Guardamos la raíz en la variable P
HH
Si (p <> Nulo) entonces // cuando p es diferente de Nulo,
insertamos en la pila y nos movemos a los hijos izquierdos
Escriba info(p) // Se escribe la información del nodo donde
estemos ubicados (P).
Inpila (pila, tope, tam, p) // Se incluye la dirección de los nodos
por los que vayamos pasando.
p←izq(p) // Nos movemos al hijo izquierdo
Sino //Cuando P es Nulo, debemos empezar a movernos a los hijos derechos
Canpila (pila, tope, tam,p)//Sacamos de la pila para recuperar las
direcciones de p diferentes de Nulo y continuar moviéndonos a la
derecha.
p←der(p) // Moviéndonos al hijo derecho
Fin si
Fin HH (tope =0 y P = Nulo) // Se termina cuando la pila queda vacía y P se hace Nulo
Fin-SUB
El algoritmo recursivo:
Sub Preorden (raíz)
Si (raíz<>Nulo)
Escriba info (raíz)
Preorden (izq(raíz))
Preorden (der(raíz))
Fin Si
Fin Subrutina
A
B
K
D
H
E
G
J
C
I
F

A(1)
B(2)
D(3)
G(4)
Preorden(B) Preorden (D) Preorden(G) Nulo
Nulo
H(5)
Preorden(H) Preorden(K) K(5)
Nulo Nulo
Nulo
Preorden (E) E (6)
Preorden( C )
C(7)
Preorden(C) Nulo
F(8)
Preorden(F) Preorden(I) I(9)
Nulo
Nulo
Preorden(J) J(10)
Nulo
Nulo
RECORRIDO INORDEN
Sub Inorden(raíz)
p←raíz // Se ubica P en la raíz
tope←0 //Usamos una pila, inicialmente vacía
HH
Si (p <> Nulo)
Inpila (pila, tope, tam, p) // Se incluye en la pila las direcciones que no sean
nulas.
P ←izq(p) // Nos movemos a la Izquierda
Sino // Cuando P se hace Nulo, se ha terminado de incluir la rama izquierda
Canpila(pila, tope, tam, p) Se saca de la Pila
Escriba info(p) //Se escribe la información del nodo que se saca de la Pila
p←der(p) // Nos movemos a la derecha
Fin Si

Fin HH (tope=0 y p =Nulo) // Se termina cuando P se hace Nulo y la pila queda vacía.
Fin Sub
El recorrido en Inorden consiste en escribir la información del hijo Izquierdo de la raíz,
luego la información de la raíz y finalmente escribir la información del hijo derecho.
Teniendo en cuenta que existan los hijos porque si son nulos no se escriben.
Cuando el árbol es más grande se deben seguir los siguientes pasos:
1) Nos ubicamos en la raíz del árbol principal
2) Nos movemos al subárbol izquierdo del árbol principal, si existe, se recorre el
subárbol Izquierdo en Inorden; es decir, se escribe la información del hijo
izquierdo, si este tiene subárbol izquierdo nos movemos a este nodo y
escribimos su información y continuamos y recorrindo en Inorden todos los
subárbol izquierdo hasta que no hayan más subárboles izquierdos.
3) Escribimos la raíz del ultimo subárbol izquierdo
4) Nos movemos hacia el subárbol derecho, escribimos su información y
seguimos recorriéndolo en Inorden.
5) El proceso anterior se repite hasta cuando pasemos por todos los nodos de la
lista.
Sub Inorden (raíz)
Si (raíz<> Nulo)
Inorden(izq(raíz))
Escriba info(raíz)
Inorden(der(raíz))
Fin Si
Fin Sub
A
B
A
C
Recorrido en Inorden
BAC
A
B
K
D
H
E
G
J
C
I
F

Nulo
Inorden( G) G(1)
Nulo
Inorden (D) D D (2)
Inorden( k) K(3)
Inorden( H ) H H(4)
Nulo Nulo
Inorden(B) B B(5)
Inorden (E) Nulo
E(6)
Nulo
A A(7)
Nulo
Inorden(C) C C(8)
Nulo
Inorden
I
Nulo
Inorden( F) F
Inorden(G)
RECORRIDO POSTORDEN

Sub Postorden(raíz)
Si (raíz <>Nulo)
Postorden(izq(raíz))
Postorden(der(raíz))
Escriba info(raíz)
Fin Si
Fin
RECORRIDO POR NIVELES.
En el recorrido por Niveles, nos ubicamos en la raíz y realizamos los siguientes pasos:
1. Guardamos en una cola esta dirección,
2. Luego cancelamos de la cola y escribimos su información
3. Nos movemos al hijo izquierdo y si es distinto de nulo lo guardamos en la cola
4. Nos movemos al hizo derecho y si existe lo guardamos en la cola.
5. Continuamos repitiendo el proceso desde el paso 2.
6. Se finaliza cuando la cola quede vacía.
SUB Niveles(raíz)
p←raíz // Se almacena en P la dirección de la raíz
tope←0
tam←50
Incola(cola, base, tope, tam, p) //Se guarda la dirección de la raíz en una cola
MQ (base<>tope) Mientras que la cola no este vacía
|Cancola(cola, base, tope, tam, p) // Se elimina de la cola por base
Escriba info(p) //Escribe la información del nodo cancelado
Si (izq(p) <>Nulo) //Si el nodo cancelado tiene hijo izquierdo
Raíz
A
B
K
D
H
E
G
J
C
I
F
Recorrido por Niveles:
A B C D E F G H I J K

Incola(cola, base, tope, tam, izq(p)) //Se incluye en la cola la
dirección del hijo izquierdo)
Fin Si
Si (der(p)<>Nulo)// Si el nodo cancelado tiene hijo derecho
Incola(cola, base, tope, tam, der(p)) //Se incluye en la cola la
dirección del hijo derecho)
Fin Si
Fin MQ
Fin Subrutina
Prueba de escritorio al algoritmo del recorrido por Niveles:
P Tope Base Tam Cola Orden de
Escritura
de los nodos
Dir(A) 0 0 50
1 Dir(A)
1 A
2 Dir(B)
3 Dir(C)
Dir(B) 2 B
4 Dir(D)
5 Dir (E)
DIR(C) 3 C
6 DIR(F)
DIR(D) 4 D
7 DIR(G)
8 DIR(H)
DIR(E) 5 E
DIR(F) 6 F
9 DIR(I)
10 DIR(J)
DIR(G) 7 G
DIR(H) 8 H
11 DIR(K)
DIR(I) 9 I
DIR(J) 10 j
DIR(K) 11 K
Observe que la Base= Tope = 11 ( La cola queda vacía y termina el recorrido)
EJERCICIOS DE ARBOLES BINARIOS
Un árbol binario es completo, si todos los nodos que no son terminales, tienen hijos.
Hacer un algoritmo que determine si un árbol binario es completo.
FuncionCompleto(raíz)
Si ((raíz <> Nulo) // Verificamos que exista el nodo
Si (der(raíz) <> Nulo y izq(raíz) = Nulo) o

(der(raiz) = Nulo y izq(raíz) <> Nulo) // Se verifica si hay nodos con un
solo hijo, si esta condición se cumple el árbol no es completo
Completo<---false // Termina el algoritmo cuando el árbol No es compelto
Sino
Completo←Completo(izq(raíz)) //Continuar el recorrido con el
Hijo izquierdo
Completo ←Completo(der(raíz)) //Continuar el recorrido con el
Hijo derecho
Sino
Completo ← True // Termina el recorrido y el árbol es completo
FinSi
Regrese
Algoritmo para eliminar las hojas de un árbol.
Consideraciones a tener en cuenta:
 Para eliminar las hojas de un árbol se requiere tener la dirección del padre. Pueden
presentarse tres casos:
1) El nodo a eliminar es la raíz, por lo tanto no tiene padre y el árbol quedaría vacio
2) El nodo a eliminar es un hijo derecho del padre
3) El nodo a eliminar es un hijo izquierdo del padre
 Se debe utilizar cualquiera de los recorridos, para ir pasando por cada nodo y
cuando no tenga ninguno hijo, eliminar el nodo.
 Usaremos el recorrido por niveles y dos colas, en la primera se guardara las
direcciones de los nodos por los que vaya pasando en el recorrido y en la segunda se
guarda las direcciones de sus respectivos padres.
 Las dos colas se trabajan paralelamente (Esto significa que, si en una de las colas se
hace una operación de inserción o de eliminación de un nodo en la otra también se
El derecho del padre debe
apuntarsea Nulo y
eliminar el nodo P.
der(pad)← Nulo
Eliminar(p)
A
B
P (Nodo a eliminar)
P
Pad (Padre del nodo a borrar)
El izquierdo del padre
debe apuntarse a Nulo y
eliminar el nodo P.
izq(pad)← Nulo
Eliminar(p)
A
B
B
P (Nodo a eliminar)
P
Pad (Padre del nodo a borrar)

debe realizar la misma operación de inserción o de eliminación, pero con su
respectivo padre).
SUB EliminaHojas( raíz)
p ← raiz // Se guarda la dirección de la raíz en la variable p
pad ← Nulo // En la variable pad se guarda Nulo, porque la raíz no tiene padre
max ← 100 // tamaño arbitrario de las colas
base ← 0; base1 ← 0; // El indicador de la bases se inicia en cero
tope ← 0: tope1 ← 0; // El indicador de los topes se inicia en cero
//Las dos colas: cola y cola1 se inicializan vacías
incola (cola, base, tope, max, p) // Se incluye en cola la dirección de la raiz
incola (cola1, base1, tope1, max, pad) // Se incluye en cola la dirección del padre de la raiz
MQ ((base <> tope) haga // Mientras que la cola no este vacía
cancola (cola, base, tope, max, p)// Se cancela de la cola el nodo correspondiente
cancola (cola1, base1, tope1, max, pad)//Se cancela de la otra cola su padre
Si (izq (p) = Nulo y der(p)= Nulo) entonces // Si el nodo es una hoja
Si pad = Nulo // El nodo a eliminar es la raíz- caso1
Liberar(p) // Se libera el nodo
Raiz ←Nulo // El árbol queda vacío
Sino
Si (izq(pad) = p) // El nodo a eliminar es un hijo izquierdo del padre-
caso3
izq(pad) ← Nulo // El izquierdo del padre se apunta a Nulo
Si-no // El nodo a eliminar es un hijo derecho del padre- caso2
der(pad) ←Nulo // El drecho del padre se apunta a Nulo
Fin-si
Liberar(p) // Se elimina el nodo que es una hoja
Fin-si
Sino // Se continúa el recorrido por niveles
Si (izq(p) <> Nulo) entonces // P tiene hijo izquierdo?
incola (cola, base, tope, max, izq(p)) // Se incluye el hijo izquierdo
de p
incola (cola1, base1, tope1, max, p)//Se incluye su respectivo padre
f-si
Si (der(p) <> Nulo) entonces // p tiene hijo derecho?
incola (cola, base, tope, max, der (p)) // Se incluye el hijo derecho
de p
incola (cola1, base1, tope1, max, p)// Se incluye surespectivo padre
f-si
f-si
F-MQ
Realicemos una prueba de escritorio con árbol de la figura.
A
B
A
C
D
A
E
A
F

1. Iniciamos usando dos colas vacías.
Cola
base←0 tope←0
Cola1
base1←0 tope1←0
2. Insertamos en la estructurallamada cola la raíz y en estructura cola1 su padre que es Nulo.
cola:
A
tope←1 base←0 p←A
Cola1
Nulo
tope1←1 base1←1 Pad←Nulo
3. Al no estar vacías las colas, entramos al Mientras Que.
4. Cancelamos en las dos colas y verificamos si el nodo A es una hoja.
cola:
A
Cola1
Nulo
tope1← 1 base1←1 Pad←Nulo
5. Como el nodo cancelado, NO ES UNA HOJA y tiene hijo izquierdo (B) entonces lo insertamos en la
estructurallamada cola y la dirección de su padrela incluimos en la estructura llamada Cola1 (A).
cola:
B
Cola1
A
6. Como el nodo cancelado tiene además, hijo derecho (C) entonces lo insertamos en la estructura cola y su
padre en la estructuraCola 1 (A)
cola:
B C
Cola1
A A
7. Realizamos otra iteración del Mientras Que porquelas colas no están vacías.
8. Cancelamos en las dos colas.
cola:

B C
tope←3 base←2 p←B
Cola1
A A
tope1←3 base1←2 Pad←A
9. Como B NO ES UNA HOJA y tiene hijo izquierdo (D) se incluye en cola y su padre(B) se inserta en
Cola1.
cola:
C D
Cola1
A B
10. Como B, además tiene hijo derecho (E) se incluye en cola y en cola1 se inserta su padre que es (B)
cola:
C D E
Cola1
A B B
11. Realizamos otra iteración del Mientras Que, porquelas colas no están vacías.
12. Cancelamos en las dos colas.
cola:
C D E
tope←5 base←3 p←C
Cola1
A B B
13. El nodo C no tiene ni hijo izquierdo ni hijo derecho por la cual se elimina.
Como C es un hijo derecho de A, al derecho de A se apuntaa Nulo y se elimina C de la lista que
representael árbol.
14. Realizamos otra iteración del Mientras Que, porqueaún existen elementos en la Cola.
15. Cancelamos en las dos colas
cola:
D E
tope←5 base←3 p←D
Cola1
B B
tope1←5 base1←3 Pad←B
16. El nodo D es una hoja por lo cual se elimina.
Como D es un hijo izquierdo de B, al izquierdo de B se apuntaa Nulo y se elimina D de la lista
que representa el árbol.
17. Realizamos otra iteración del Mientras Que. La cola no estavacia.

cola:
E
tope←5 base←5 p←E
Cola1
B
19 El nodo E tiene un hijo derecho(F) que se incluye en cola y su padre (E) se inserta en cola1
cola:
F
tope←6 base←5 p←E
Cola1
E
19. Realizamos otra iteración del Mientras Que
cola:
F
tope←6 base←6 p←F
Cola1
E
tope1←6 base1←6 Pad←E
21. Como el nodo F no tiene hijos se elimina de la lista.
Como F es un hijo derecho de E, al derecho de E se apuntaa Nulo y se elimina F de la lista que
representael árbol.
22 Regresamos al Mientras que y las colas están vacías, luego se termina la prueba.
Algoritmo para buscar el tío de un elemento en un árbol binario ya creado.
Vamos a hacer uso de tres colas. Cualquier operación que se haga en una debe hacerse
en la otras dos.
 Cola: Almacena las direcciones de los nodos por los que vayamos pasando en el
recorrido.
 Cola1: Almacena las direcciones de los respectivos padres de los nodos por los
que vayamos pasando en el recorrido.
 Cola2: Almacena las direcciones de los respectivos abuelos de los nodos por los
que vayamos pasando en el recorrido.
Antes de continuar, observe para algunos árboles de ejemplos que direcciones guardaría
cada cola.
R
S
T
Padre
Abuelo
P
PadreR
S P
Abuelo=Nulo
AbueloR
S
T
Padre
P

Usaremos también un recorrido por niveles.
SUB TIO (raiz, elem)
p ←raiz; pad ←Nulo; abuelo ← Nulo// Iniciamos guardando las direcciones de la
raíz en la variable p, la de su padre es la variable pad y la de su abuelo en la variable llamada abuelo
sw ← 0 // Indicador que termina la búsqueda del elemento
max ←100 // tamaño de las colas
base ← 0; base1 ← 0; base2 ← 0 // Indicadores de las bases iniciados en cero
tope ← 0: tope1 ← 0; tope2 ← 0 // Indicadores de los topes iniciados en cero
incola (cola, base, tope, max, p)// Insertando la dirección de la raíz en cola
incola (cola1, base1, tope1, max, pad) // Insertando la dirección del padre de la raíz(Nulo) en cola1
incola (cola2, base2, tope2, max, abuelo) // Insertando la dirección del abuelo de la raíz(Nulo) en
cola2
MQ ((base <> tope) y (sw = 0)) haga //Buscando el elemento usando el recorrido por
niveles
cancola (cola, base, tope, max, p)
cancola (cola1, base1, tope1, max, pad)
cancola (cola2, base2, tope2, max, abuelo)
Si (info(p) = elem) entonces // Si se encuentra el elemento
sw = 1 // Se cambia el indicador y se termina el ciclo de búsqueda
Sino
Si (izq(p) <> Nulo) entonces
incola (cola, base, tope, max, izq(p)) //Incluimos el hijo izquierdo
del nodo p en cola
incola (cola1, base1, tope1, max, p) // Incluimos al padre del
izquierdo de p, que es p, en cola1
incola (cola2, base2, tope2, max, pad) // Incluimos al abuelo
de p, que es pad, en cola2
f-si
Si (der(p) <> Nulo) entonces
incola (cola, base, tope, max, der (p)) //Incluimos el hijo derecho
del nodo p en cola
incola (cola1, base1, tope1, max, p) // Incluimos al padre del
derecho de p, que es p, en cola1
incola (cola2, base2, tope2, max, pad) // Incluimos al abuelo
de p, que es pad, en cola2
Cola
T
Cola1
S
Cola2
R
Cola
T
Cola1
S
Cola2
R
Cola
R
Cola1
Nulo
Cola2
Nulo
Se cancela en las tres colas.

f-si
f-si
F-MQ
Si (sw=1) // Encontramos a Elem en la dirección p, a su padre en la dirección pad y a su abuelo en
la dirección llamada abuelo
Si abuelo <> Nulo // Si el elemento tiene abuelo
Si (izq( abuelo)= pad y der(abuelo) <> Nulo) // Si el izquierdo
del abuelo apunta al padre del p, entonces el tío es el hijo derecho, si este
existe.
TIO ← ( der(abuelo))
Si-no
Si (der( abuelo)= pad y izq(abuelo) <> Nulo) // Si el
derecho del abuelo apunta al padre del p, entonces el tío es el hijo
izquierdo del abuelo, si este existe
TIO ← ( izq(abuelo))
Si-no
TIO←Nulo
Fin-si
Fin-si
Sino
TIO←Nulo
Fin-si
Fin-si
Fin_SUB
Realizar una prueba de escritorio a las dos FUNCIONES siguientes:
FUN xxxx (raiz)
p ← raiz
tope ← 0; tope1 ← 0
i ← 0; max ← 50 // Tamaño de la pila
MQ (p <> Nulo ) haga
inpila (pila, tope, max, p)
inpila (pila1, tope1, max, i)
p ← izq(p)
i ← i+1
Fin-MQ
h ← i -1
MQ (tope <> Nulo) haga
canpila (pila,tope,max, p)
canpila (pila1, tope1, max,i)
Si (i > max) entonces
h ← i
f-Si
i ← i+1
p ← der(p)
MQ (p <> Nulo) haga
inpila (pila, tope, max, p)
inpila (pila1, tope1, max, i)
i← i + 1

p ← izq(p)
F-MQ
F-MQ
Regrese h
FIN-función
FUN YYYY (raiz)
p = raiz
base1 = 0; base2 = 0
tope1 = 0; tope2 = 0
max = 50; nivel = 0 // max es el tamaño de las colas
incola (cola1, base1, tope1, max, p)
incola (cola2, base2, tope2, max, nivel)
MQ (base1 <> tope1) haga
cancola (cola1, base1, tope1, max, p)
cancola (cola2, base2, tope2, max, nivel)
Si (izq(p) <> Nulol) entonces
incola (cola1, base1, tope1, max, izq(p))
l incola (cola2, base2, tope2, max, nivel+1)
f-si
Si (der(p) <>Nulo) entonces
incola (cola1, base1, tope1, max, der(p))
incola (cola2, base2, tope2, max, nivel+1)
f-si
f-MQ
YYYY = nivel
FIN-FUN
Completar las instrucciones que faltan para encontrar el primo de un elemento
llamado elem
SUB PRIMOELEM (raiz, elem)
p = raiz; pad = Nulo; abuelo = Nulo
sw = 0
max = 100
base = 0; base1 = 0; base2 = 0
tope = 0: tope1 = 0; tope2 = 0
incola (cola, base, tope, max, p)
incola (cola1, base1, tope1, max, pad)
incola (cola2, base2, tope2, max, abuelo)
MQ ((base <> tope) y (sw = 0)) haga
cancola (cola, base, tope, max, p)
cancola (cola1, base1, tope1, max, pad)
cancola (cola2, base2, tope2, max, abuelo)
Si (info(p) = elem) entonces
sw = 1

Sino
incola (cola, base, tope, max, izq(p))
f-si
Si (der(p) <> Nulo) entonces
incola (cola, base, tope, max, der (p))
f-si
f-si
F-MQ
Si (sw=1)
______________________________________________________________________
______________________________________________________________________
______________________________________________________________________
______________________________________________________________________
______________________________________________________________________
______________________________________________________________________
______________________________________________________________________
______________________________________________________________________
3) Si todos los elementos de un árbol binario de números enteros, cumplen con las
siguientes condiciones: La información del hijo Izquierdo es Menor que la
información de su padre y la información del hijo derecho es mayor que su padre.
Esto es un árbol ORDENADO.
Observe el ejemplo:
FUN Ordenado ( raíz)
p = raiz; pad = Nulo
tope1 = 0; base1 = 0; max = 100; sw = false
incola(q1, base1, tope1, max, p)
MQ (base1 <> tope1 y sw ) haga
cancola (q1, base1, tope1, max, p)

incola (q1, base1, tope1, max, izq(p))
Si (info ( izq(p) > info(p))
sw = true
Fin-si
fin-si
Si (der(p) <> Nulo y sw= 0 )entonces
incola (q1, base1, tope1, max, der(p))
Si (info ( der(p) < info(p))
sw = true
Fin-si
Fin-si
Fin-MQ
Regrese sw
FIN-proc
Complete las instrucciones que faltan a la siguiente función para verificar si un árbol
binario ya creado es estable. Un árbol binario de valores enteros es estable si para todo
elemento de la estructura la información de su padre es mayor que la de sus hijos.
FUNCION EstableRecursivo (raíz, pad, sw )
Si (raiz <> Nulo y sw=0 ) entonces
EstableRecursivo (izq(raiz), p )
EstableRecursivo (der(raiz), p )
f-si
Fin-fun
Algoritmo para escribir el recorrido por niveles desde la Hojas hasta raíz de un árbol
binario ya creado.
SUB RecorridoHojasRaiz (raiz)
p = raiz // Se utiliza el recorrido por niveles
tam = 30
base = 0; tope=0; tope1=0
incola (cola, base, tope, tam, p)
inpila( pila, tope1, tam, p)
MQ (base <> tope) haga
cancola (cola, base, tope, tam, p)
inpila( pila, tope1, tam, p) //Cada elemento cancelado se guarda en una
pila
Si (der(p) <> Nulo) entonces// En el recorrido por niveles primero se
guarda el hijo derecho, si existe y luego el hijo izquierdo si existe.
incola (cola, base, tope, tam, der(p))
f-si
FDEBCA
A
B
A
C
D
A
E
A
F

incola (cola, base, tope, tam, izq (p))
f-si
F-MQ
Escribirpila( pila, tope1, tam,p)// Escribir la información de las direcciones
almacenadas en la pila.
FIN-SUB
Dado un árbol binario ya creado raiz1, realice un algoritmo para crear otro árbol
binario raiz2 con el reflejo del árbol raiz1.
SUB Espejo (raiz1, raiz2)
P ← raiz1 // Nos ubicamos en la raíz del árbol dado
// Se hace un recorrido por niveles en el árbol raiz1 y a medida que se avanza se va creando el árbol raiz2
// teniendo en cuenta que los dos árboles van a tener la misma información de la raíz, pero que un hijo
//izquierdo de raiz1 va a ser un hijo derecho en raíz2 y visceversa.
//tenga cuidado que son dos árboles diferentes el árbol dado y el que se va a crear que es espejo.
max ← 100// Tamaño de las colas
tope←0 , tope1←0
obtener (s)// Obtenemos un nodo
info(s) ← info (raiz1) // Se le asigna la misma información de la raíz del árbol dado
raiz2 ← s // Se crea la raíz del nuevo árbol reflejo(raiz2)
t ← s
incola (cola, b, tope, max, p)// En cola se guarda la dirección de la raíz del árbol raiz1
incola (cola1, b1, tope1, max, s) // En cola1 se guarda la dirección de la raíz del árbol raiz2
MQ (b <> tope) haga
cancola (cola, b, tope, max, p)// p almacena las direcciones del arbol1
cancola (cola1, b1, tope1, max, t) // t almacena las direcciones del arbol2 que se va a
crear
Si (izq(p) <> Nulo) entonces // El árbol1 tiene hijo izquierdo?
obtener (s) // Si tiene hijo izquierdo, se obtiene un nodo S
info (s) ← info (izq(p)) // Se guarda la info del hijo izquierdo en el nodo s.
der (t) ← s // En el arbol2 este nodo viene a ser un hijo derecho
incola (cola, b, tope, max, izq(p)) // En cola se guarda el izquierdo de p
incola (cola1, b1, tope1, max, s) // En cola1 se guarda el derecho de t,
que es el mismo s.
f-si
A
B
A
C
D
A
E
A
F
A
C
A
B
E D
F

Si (der(p) < > Nulo) entonces // El árbol1 tiene hijo derecho?
obtener (s) //Si tiene hijo derecho, se obtiene un nodo S
info (s) ← info (der(p)) Se guarda la info del hijo derecho en el nodo s
izq (t) ← s // En el arbol2 este nodo viene a ser un hijo izquierdo
incola (cola, b, tope, max, der(p)) // En cola se guarda el derecho de p
incola (cola1, b1, tope1, max, s) En cola1 se guarda el izquierdo de t o s.
f-si
f-MQ
FIN_SUB
Escriba cual es la rama más larga. Suponga que existe una sola que cumple la
condición.
SUB Niveles (raíz, Pila3, tope3, Pila4, Tope4)
Tope10, base10, Tope20, base20
praiz
pad  Nulo
incola (Cola1, tope1,base1, Tam, p)
incola (Cola2, tope2,base2, Tam, pad)
MQ (base1 <> tope1)
cancola (Cola1, tope1, base1, max, p)
cancola (Cola2, tope2, base2, max, pad)
inpila (Pila3, tope3, Tam, p)
inpila (Pila4, tope4, Tam, pad)
Si (izq(p) <> NULO)
incola (Cola1,tope1, base1, max, izq(p))
incola (Cola2, tope2, base2, max, p)
F-si
Si (der(p) <> NULO)
incola (q, tope1, base1, max, der(p))
incola (r, tope2, base2, max, p)
F-si
F-MQ
FIN-SUB
SUB Ramalarga (raiz)
Niveles (raiz, pila3, tope3,pila4, tope4)// Llamando la subrutina anterior
canpila (pila3, tope3, max, p)// Cancelamos el primer elemento de la pila3(F)
canpila (pila4, tope5, max, pad) // Cancelamos el primer elemento de la pila4(E)
tope5←0 // Iniciamos el tope5 de otra pila5 que guardara la rama más larga
inpila (pila5, tope5, max, p) // Almacenamos en la pila5 a F
inpila (pila5, tope5, max, pad)// Almacenados en la Pila5 a E( Padre de F)
ultpad ← pad // Guardamos la dirección de E que corresponde al último padre
HH
canpila (pila3, tope3, max, p) // Seguimos cancelando en la pila3
canpila (pila4, tope4, max, pad)// paralelamente cancelados en la pila4
Si ulpad=p // Cuando encontremos que la dirección de p coincide con el ultimo padre
Esta subrutina regresa dos pilas:
Pila3 con el recorrido por Niveles
A B C D E F
Pila4consus respectivos padres
Null A C B B E
A
B
A
C
D
A
E
A
F
Esta subrutina regresa dos pilas:
Pila3 con el recorrido por Niveles
A B C D E F
Pila4consus respectivos padres
Null A C B B E
Pila5
F E
ultpad←E

inpila (pila5, tope5, max, pad) // guardamos en Pila5 el pad
ultpad = pad // Actualizamos en ultimo padre con pad
Fin-si
FIN-HH (p= raíz) // Se termina el ciclo porque llegamos a la raíz.
Mq tope5 <> 0
Llamar canpila(pila5, tope5, max, p)
Escriba info(p)
Fin-Mq
FIN-SUB
Hacer un algoritmo que escriba si dos árboles ( raiz1, raiz2) son Isomorfos. Para que
dos árboles sean isomorfos se necesita que tengan la MISMA FORMA sin importar la
información
Fun Isomorfos (raìz1,raìz2, sw)
Si ( raìz1 <> NULO y raìz2 <>NULO y sw )entonces
Si (izq(raìz1) <>NULO y izq(raìz2)=NULO) o
(izq(raìz1)=NULO) y (izq(raìz2) <>NULO)) o
(der(raìz1)=NULO)y (der(raìz2) <>NULO) o
(der(raìz1) <>NULO) y der(raiz2)=NULO)
sw= False
Sino
Isomorfo(izq(raìz1),izq(raìz2), sw)
Isomorfo(der(raìz1),der(raìz2), sw)
Fsi
Fin-si
Isomorfo sw
FIN-fun
Encuentre los errores en siguiente algoritmo que elimina los elementos que se
encuentran en el último nivel.
SUB EliminarElemÚltNiv (Raíz)
base=0; base1=0
p=raíz; pad=Nulo
tope=0; tope1=0
tam=50
INCOLA(cola, base, tope, tam, p)
INCOLA(cola1, base1, tope1, tam, pad)
MQ ( base <> tope) haga
CANCOLA(cola, base, tope, tam, p)
CANCOLA(cola1, base1, tope1, tam, pad)
Pila5
F E B A
Escribe A,B,E,F

SI( IZQ( P )=Nulo ^ DER( P )=Nulo ) entonces
SI( pad <> Nulo) entonces
SI( IZQ( pad )=p ) entonces
IZQ( pad )= Nulo
SINO
DER( pad )= Nulo
F.SI
SINO
raíz= Nulo
F.SI
liberar ( P )
SINO
SI ( IZQ ( P )<>Nulo) entonces
INCOLA(cola, base, tope, tam, IZQ ( P ))
F.SI
SI ( DER ( P )<>Nulo) entonces
INCOLA(cola, base, tope, tam, DER ( P ))
F.SI
F.SI
F.MQ
FIN SUB
EJERCICIOS PROPUESTOS
1. Hacer un algoritmo que elimine los elementos que se encuentran en el
último nivel.
2. La anchura de un nivel se define como el número de elementos presentes
en dicho nivel. La gordura de un árbol binario corresponde al valor
máximo de las anchuras de sus niveles. Un recorrido por niveles más
gordos ó por anchura; empieza por el nivel más gordos hasta el más
flaco. Hacer un algoritmo para recorre un árbol en Anchura. Observe el
ejemplo. Suponga que hay uno solo más gordo.
ARBOLES ORDENADOS
Los árboles ordenados denominados también árboles de búsqueda binaria se
caracterizan porque los elementos que se encuentran a la izquierda de la raíz son
menores que la información de está y los que se encuentran a la a derecha son mayores
que la información de la raíz, la regla anterior se debe cumplir para todos subárboles de
los que se compone el árbol.
BÚSQUEDA EN UN ARBOL ORDENADO

Proc Busorden(raiz,elem,p,pad)
p=raiz
pad=Nulo
existe= `no`
MQ ((existe= =`no`)y(p<>Nulo))
Si (info(p)<elem)
pad=p
p=der(p)
sino
Si (info(p)>elem)
pad=p
p=izq(p)
sino
existe=`si`
fsi
fsi
fin _MQ
FIN-proc
Buscar recursivo
Sub Busorden (elem,p,pad, sw)
Si (p<>Nulo y sw=0)
Si (info(p)<elem)
busorden(elem,der(p),p, sw)
Sino
Si (info(p)>elem)
busorden(elem,izq(p),p, sw)
Sino
Sw = 1
Fin-si
Fin-si
Fin-si
Fin-Sub
INSERTAR UN NODO EN UN ARBOL ORDENADO.
Los nodos se insertan como terminales, haciendo cumplir la definición de un árbol
ordenado.
Proc Insertar-Orden(raiz,elem){

Si raiz= = Nulo
Obtener t
Info(t)=elem
Izq(t)=Nulo
Der(t)=Nulo
Raiz=t
Sino
Llamar busorden (Raiz, elem, p, pad) ( Se está llamando al
procedimiento no recursivo)
Si (p= = Nulo)
Obtener t
Info(t)<-elem
Izq(t)<-Nulo
Der(t)<-Nulo
Si (info(pad)<info(t))
Izq(pad) = t
sino
Der(pad) = t
finsi
Sino
Escriba “No se puede insertar nodo por tener información
repetida, ojo!”
Finsi
Fin-si
FINPROC
ELIMINACIÓN DE UN NODO EN UN ÁRBOL ORDENADO
En el siguiente algoritmo si el nodo a eliminar tiene dos hijos, este se remplaza por el
Mayor de los menores( Se mueve una vez a la izquierda y luego tantas veces a la
derecha hasta que no haya más derecho)
Proc EliminarOrdenado(raiz,elem)
Llamar BuscarOrden(raiz,elem,p,pad)
Si (p<>Nulo)
Si ((izq(p) =Nulo y der(p)= Nulo))
Si (pad= Nulo)
raiz=Nulo
sino
Si (izq(pad)= p)
Izq(pad)=Nulo
sino
der(pad)=Nulo
fin-si
fin-si
sino
Si (izq(p)<>Nulo y der(p)<>Nulo)
ant=p

t = izq(p)
MQ (der(t)<>Nulo)
ant=t
t=der(t)
Fin_MQ
info(p)=info(t)
Si (ant= =p)
izq(ant)=izq(t)
sino
der(ant)=izq(t)
fin-si
p=t
izq(p)=Nulo
sino
Si (izq(p)<>Nulo){
Si (pad= Nulo)
raiz=izq(p)
sino
Si (der(pad)= =p)
der(pad)=izq(p)
sino
izq(pad)=izq(p)
fin-si
fin-si
izq(p)=Nulo
sino
Si (pad=Nulo){
raiz=der(p)
sino
Si (der(pad)=p)
der(pad)=der(p)
sino
izq(pad)=izq(p)
fin-si
fin-si
der(p)=Nulo
fin-si
fin-sis
liberar(p)
}fin-si
EEssttrruuccttuurraa ddee DDaattooss:: ÁÁrrbboolleess..

Ejercicios Propuestos:
1. Realice un algoritmo que permita Guardar en una lista simple, un nivel dado por
el usuario.
2. Eliminar un árbol deshojándolo no debe quedar la raíz.
3. Eliminar las hojas de un árbol; revisando la información de la hoja y eliminar el
vecino a la distancia info. de la hoja, solo si dicho vecino existe, si el nodo a
eliminar tiene 2 hijos, se debe colocar el hijo de info. mayor como padre y el
menor como hijo.
4. Realice una función que permita conocer el número total de nodos que contiene
el árbol.
5. Diseñe una subrutina recursiva que permita realizar el recorrido por niveles.
6. Realice la función que devuelva el tío de un nodo, cuya información es Elem.
7. Cree una lista simple que almacene todos los primos de un nodo, que tienen
como información Elem.
8. Idee una función que devuelva el abuelo de un Elem dado.
9. Haga un algoritmo que devuelva el Nodo que tiene el mayor info.
10. Cree una función que retorne el Nodo menor de un árbol, con respecto al info.
11. Realice un algoritmo que tronche una rama, por tronchar una rama se entiende
invertir el hijo derecho por el padre, utilizando los links.
12. Haga un algoritmo que invierta los hijos de un Subárbol.
13. Idee la manera de rotar un Subárbol, rotar es mover al padre y colocarlo a la
derecha, el nodo hijo derecho colocarlo como hijo Izquierdo, y por ultimo al
Hijo Izquierdo colocarlo como Padre.
14. Hacer un algoritmo que pode un árbol; por podar se entiende que para cada nivel
se debe cumplir que: NnodosNivelAnterior + 2 = NnodosNivelSiguiente,
luego eliminar los nodos pares hasta que se cumpla la formula.

15. Realice una función que indique si el árbol es Máximo; un árbol es Máximo
cuando para cada nodo existente en el árbol tiene nos hijos, excepto las hojas.
16. Haga un función que recorra un árbol binario y retorne True si, la información del
padre es mayor que la información del hijo izquierdo, a su vez sea menos que la
información del hijo derecho, de lo contrario retorne False.

Árboles estructura

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (18)

Similar a Árboles estructura

Similar a Árboles estructura (20)

Último

Último (20)

Árboles estructura