Professional Documents
Culture Documents
Árboles binarios
• Un árbol binario es un árbol en el que ningún nodo puede tener más de dos sub árboles
binario, cada nodo puede tener, cero, uno o dos hijos (sub árboles). Se conoce el nodo de
como hijo izquierdo y el nodo de la derecha como hijo derecho.
• Se define un árbol binario como un conjunto finito de elementos (nodos) que bien está
vació o está formado por una raíz con dos árboles binarios disjuntos, llamados subárbol
izquierdo y derecho de la raíz.
En los apartados que siguen se considerarán únicamente árboles binarios y, por lo tanto, se
utilizará la palabra árbol para referirse a árbol binario. Los árboles de grado superior a 2 reciben el
nombre de árboles multicamino.
Árbol binario de búsqueda.- Los árboles binarios se utilizan frecuentemente para representar
conjuntos de datos cuyos elementos se identifican por una clave única. Si el árbol está organizado
de tal manera que la clave de cada nodo es mayor que todas las claves su subárbol izquierdo, y
menor que todas las claves del subárbol derecho se dice que este árbol es un árbol binario de
búsqueda.
Nota
Página 1
ESTRUCTURA DE DATOS ITP
Un árbol binario es una estructura recursiva. Cada nodo es la raíz de su propio subárbol y tiene
hijos, que son raíces de árboles llamados los sub árboles derecho e izquierdo del nodo,
respectivamente.
--Mediante punteros
--Mediante arrays.
Cada nodo de un árbol será un registro que contiene al menos tres campos:
<dato> datos;
};
La estructura de un árbol binario se construye con nodos. Cada nodo debe contener el campo dato
(datos a almacenar) y dos campos punteros, uno subárbol izquierdo y otro al subárbol derecho,
que se conocen como puntero izquierdo (izquierdo, izdo.) y puntero derecho (derecho, dcho.)
respectivamente. Un valor NULL indica un árbol vacío.
Página 2
ESTRUCTURA DE DATOS ITP
Un árbol binario de búsqueda se puede utilizar cuando se necesita que la información se encuentre
rápidamente. Estudiemos un ejemplo de árbol binario en el que cada nodo contiene información
relativa a una persona. Cada nodo almacena un nombre de una persona y el número de matrícula
en su universidad (dato entero).
Declaración de tipos
Nombre
Matricula
struct nodo {
int nummat;
char nombre [ 30 ] ;
struct nodo *izda, *dcha;
};
typedef struct nodo Nodo;
Creación de un nodo
La función tiene como entrada un dato entero que representa un número de matrícula y el nombre.
En java
package arbolbinario;
public class Nodo
{
protected Object dato;
Página 3
ESTRUCTURA DE DATOS ITP
A continuación se hará una breve descripción de los diferentes tipos de árbol binario así como un
ejemplo de cada uno de ellos.
Página 4
ESTRUCTURA DE DATOS ITP
Los árboles enhebrados son una representación ideada por A.J. Perlis y C. Thornton en el año
1960, que permite implementar los recorridos sin necesidad de espacio adicional (como mucho, un
par de booleanos de marca en cada nodo), y se basa en la propiedad ya conocida de que una
representación encadenada normal de los árboles desaprovecha muchos apuntadores que no
apuntan a ningún nodo. En el caso binario, de los 2n encadenamientos existentes en un árbol de n
nodos hay exactamente n+1 sin usar. Por ello, es bueno plantearse si se pueden reciclar estos
apuntadores para llevar a cabo cualquier otra misión, y de ahí surge el concepto de hebra: cuando
un nodo no tiene hijo derecho, se sustituye el valor nulo del encadenamiento derecho por su
sucesor en orden, y cuando no tiene hijo izquierdo, se sustituye el valor nulo del encadenamiento
izquierdo por su predecesor en orden; de esta manera, se favorece la implementación de los
recorridos sobre el árbol.
Un árbol binario completo que contiene 2" nodos a nivel n es un árbol lleno. Un árbol lleno es un
árbol binario que tiene el máximo número de entradas para su altura. Esto sucede cuando el último
nivel está lleno.
Página 5
ESTRUCTURA DE DATOS ITP
Árbol es un tipo especial denominado árbol degenerado en el que hay un solo nodo hoja (E) y cada
nodo no hoja sólo tiene un hijo. Un árbol degenerado es equivalente a una lista enlazada.
1 + 2 + 4 +... + 2k = 2k-1
A nivel k, el número de nodos adicionados para un árbol completo está en el rango de un mínimo
de 1 a un máximo de 2L (lleno). Con un árbol lleno, el número de nodos es
1 + 2 + 4 +... + 2k + 2k = 2k+1 -1
Página 6
ESTRUCTURA DE DATOS ITP
Por ejemplo, un árbol lleno de profundidad 4 (niveles O a 3) tiene 24-1 -1= 15 nodos.
Este tipo de árbol sus últimos niveles de subárboles no apuntan hacia nulo sino que se unen con
hilos punteados sustituyéndolos a estos apuntadores en los nodos con subárboles derechos
vacios. Esto se denomina arboles interhilvanados derechos.
*
-
+
3
12
4 1
Árbol binario heterogéneo
A menudo, la información que contiene diferentes nodos de árbol binario no es todo del mismo
tipo. Por ejemplo, al representar una expresión binaria con operándos numéricos constantes,
pretendemos usar un árbol binario cuyas hojas contengan números, pero cuyos nodos no
contengan operadores que presentan caracteres .La figura muestra este tipo de árbol binario.
Página 7
ESTRUCTURA DE DATOS ITP
+
*
/
3
12
4 1
• Una tarea muy común a realizar con un árbol es ejecutar una determinada operación con
cada uno de los elementos del árbol. Esta operación se considera entonces como un
parámetro de una tarea más general que es la visita de todos los nodos o, como se
denomina usualmente, del recorrido del árbol.
• Puede haber muchas tareas a realizar con una estructura de árbol; una de corriente es
ejecutar una operación P con cada uno de los elementos del árbol. P se considera
entonces como un parámetro de una tarea mas general que es la visita a los nodos o,
como se denomina usualmente, del recorrido del árbol.
• Se aplican varias operaciones primitivas a n árbol binario. Si p es un apuntador a un nodo
de un árbol binario, la función info(p) retorna el contenido de nodo.
Las funciones left(p), rigth(p), father(p), brother(p); retornan apuntadores al hijo izquierdo
de nodo , al hijo derecho de nodo , al padre de nodo y así respectivamente.
Estas funciones retornan al apuntador null si no tiene padre, hijo izquierdo, hijo derecho, o
hermano.
Si se considera la tarea como un proceso secuencial, entonces los nodos individuales se visitan en
un orden específico, y pueden considerarse como organizados según una estructura lineal. De
hecho, se simplifica considerablemente la descripción de muchos algoritmos si puede hablarse del
proceso del siguiente elemento en el árbol, según un cierto orden subyacente.
PROFUNDIDAD
Página 8
ESTRUCTURA DE DATOS ITP
La profundidad de un árbol binario es una característica que se necesita conocer con frecuencia
durante el desarrollo de una aplicación con árboles. La función Profundidad evalúa la profundidad
de un árbol binario. Para ello tiene un parámetro que es un puntero a la raíz del árbol.
El método de cálculo de la profundidad de los sub árboles utiliza llamadas recursivas a la función
Profundidad con punteros a los respectivos sub árboles como parámetros de la misma. La función
Profundidad devuelve como resultado la profundidad del subárbol mas profundo más I (la misma
de la raíz).
La altura de un árbol dependerá del criterio que se siga para definir dicho concepto. Así, si en el
caso de un árbol que tiene nodo raíz, se considera que su altura es 1, la altura del árbol es 2, y la
altura del árbol es 4. Por último, si la altura de un árbol con un nodo es 1, la altura de un árbol
vacío (el puntero es NULL) es O.
Página 9
ESTRUCTURA DE DATOS ITP
Función que determina la altura de un árbol binario de manera recursiva. Se considera que la
altura
de un árbol vacío es O; si no está vacío. La altura es I + máximo entre las alturas de rama
izquierda y derecha.
int altura(Nodo* r)
{
if (r == NULL)
return 0;
else
return (1 + max(alturd(r-zizda),altura(r>dcha))));
• Recorrido en profundidad
• Recorrido en nivel
• Recorre el árbol por sub árboles hay tres formas:
Pre orden, in orden y post orden.
Página 10
ESTRUCTURA DE DATOS ITP
Regla
En el recorrido pre orden, la raíz se procesa antes que los sub árboles izquierdo y derecho.
Página 11
ESTRUCTURA DE DATOS ITP
Si utilizamos el recorrido pre orden del árbol de la Figura se visita primero el raíz (nodo A).
Dado que el subárbol es a su vez un árbol, se visitan los nodos utilizando el orden NID.
Por consiguiente, se visita primero el nodo B, después D (izquierdo) y, por último, E (derecho).
• Recorrido en orden
El recorrido en orden procesa primero el subárbol izquierdo, después el raíz y a continuación el
subárbol derecho. El significado de in es que la raíz se procesa entre los sub árboles. Si el árbol no
está vacío, el método implica los siguientes pasos:
• Inicio
• Recorrer el subárbol izquierdo
• Visitar el nodo raíz
• Recorrer el subárbol derecho
• Fin
Página 12
ESTRUCTURA DE DATOS ITP
Fin enorden
El recorrido post orden (IDN) procesa el nodo raíz (post) después de que los sub árboles izquierdo
y derecho se han procesado. Se comienza situándose en la hoja más a la izquierda y se procesa.
A continuación se procesa su subárbol derecho. Por último se procesa el nodo raíz. Las etapas del
algoritmo son:
Inicio
Post orden (subárbol izquierdo del raíz de A)
Página 13
ESTRUCTURA DE DATOS ITP
Códigos en java
//recorridos en un árbol binario en preorden
public static void preorden(Nodo r)
{
If(r! =null)
{
r.visitar ();
Preorden (r.ubarbolizdo ());
Preorden (r.subarboldcho ());
Página 14
ESTRUCTURA DE DATOS ITP
{
inorden(r.ubarbolizdo());
r.visitar();
inorden(r.subarboldcho());
}
}
{
postorden(r.ubarbolizdo());
postorden(r.subarboldcho());
r.visitar();
}
}
Página 15
ESTRUCTURA DE DATOS ITP
• Función inserta
• Función eliminar
• Función eliminar árbol
• Visita a los nodos de un árbol (si los hay)
Función insertar ( )
La función insertar que pone nuevos nodos es sencilla. Se deben declarar tres argumentos: un
puntero al raíz del árbol, el nuevo nombre y número de matrícula de la persona. La función creará
un nuevo nodo para la nueva persona y lo inserta en el lugar correcto en el árbol de modo que el
árbol permanezca como binario de búsqueda.
La operación de inserción de un nodo es una extensión de la operación de búsqueda. Los pasos a
seguir son:
El código C de la función:
Página 16
ESTRUCTURA DE DATOS ITP
En java
return raizSub();
}
Eliminación eliminar ()
Página 17
ESTRUCTURA DE DATOS ITP
Resulta
Página 18
ESTRUCTURA DE DATOS ITP
(*r) = q->dcha;
else if (q->dcha == NULL)
(*r) = q->izda;
else
{ /* tiene rama izda y dcha. Se reemplaza por el mayor
de los menores * /}
Nodo* a, *p;
P = q;
a = q->izda;
while (a->dcha) {
p = a;
a = a->dcha;
}
q->nummat = a->nummat;
strcpy(q->nombre,a->nombre);
if (p == q)
p->izda = a->izda;
else
p->dcha = a->izda;
q = a;
}
free(q) ;
}
En java
Página 19
ESTRUCTURA DE DATOS ITP
{
nodo iz;
iz=insertar(raizSub.subarbolizdo(),dato);
raizSub.ramaizdo(iz);
}
else if(dato.mayorque(raizSub.valornodo()))
{
nodo dr;
dr=insertar(raizSub.subarboldcho(),dato);
raizSub.ramadcho(dr);
}
else//nodo encontrado
{
Nodo q;
q=raizSub;//nodo a quitar del arbol
if(q.subarbolizdo()==null)
raizSub=q.subarbldcho();
else if(q.subarboldcho()==null)
raizSub=q.subarbolizdo();
else
{
q=reemplazar(q);//tiene rama izquierda y derecha
}
q=null;
,
return raizSub;
Página 20
ESTRUCTURA DE DATOS ITP
a=act.subarbolizdo();
while(a.subarboldcho()!=null)
{
p=a
a=a.subarboldcho();
}
act.nuevoValor(a.valornodo());
if(p==act)
p.ramaizdo(a.subarbolizdo());
else
p.ramadcho(a.subarboldcho());
return a;
En muchas aplicaciones se desea explorar (recorrer) los nodos de un árbol pero sin tener en
cuenta un orden de recorrido preestablecido. En esos casos, el cliente o usuario es libre para
utilizar el algoritmo oportuno.
La función Contar Hojas recorre el árbol y cuenta el número de nodos hoja. Para realizar esta
operación se ha de visitar cada nodo comprobando si es un nodo hoja. El recorrido utilizado será el
Postorden.
/ * Función ContarHojas
la función utiliza recorrido postorden
en cada visita se comprueba si el nodo es un nodo hoja
(no tiene descendientes)
*/
void contarhojas (Nodo" r, int* nh)
{
if (r != NULL)
{
contarhojas (r -> izda, nh) ;
contarhojas (r -> dcha, nh) ;
Página 21
ESTRUCTURA DE DATOS ITP
Utiliza un recorrido postorden para liberar todos los nodos del árbol binario. Este recorrido asegura
la liberación de la memoria ocupada por un nodo después de haber liberado su rama izquierda y
derecha.
Página 22
ESTRUCTURA DE DATOS ITP
almacena la información sobre esa persona; en el caso de que la información sobre la persona no
se encuentra se devuelve el valor O. El algoritmo de búsqueda es el siguiente:
En java
package arbolbinarioOrdenado;
public interface comparador
{
boolean igualque(object q);
boolean menorque(object q);
boolean menorigualque(object q);
boolean mayorque(object q);
boolean mayorigualque(object q);
Página 23
ESTRUCTURA DE DATOS ITP
dato=(comparador)buscado;
if(raiz==null)
return null;
else
return localizar(raizArbol(),dato);
}
protected Nodo localizar(Nodo raizSub,Comparador buscado)
{
if (raizSub==null)
return null;
else if (buscado.igualque(raiz.Sub.valornodo()))
return raiz;
else if (buscado.menorque(raiz.Sub.valornodo()))
return localizar(raizSub.subarbolizdo(),buscado);
else return localizar(raizSub.subarboldcho(),buscado);
if (dato.igualque(raiz.Sub.valornodo())
encontrado=true;
else if (dato.menorque(raiz.Sub.valornodo())
raizSub=raizSub.subarbolizdo();
else
raizSub=raizSub.subarboldcho();
}
return raizSub;
}
Página 24
ESTRUCTURA DE DATOS ITP
Inserción
Definición:
El Concepto de Inserción ya es familiar para nosotros y sabemos que para realizar el mismo no
resulta complejo el procedimiento.
Pero en los Árboles en Montón es uno de los Métodos más largos para efectuarlo.
Detalle:
Después básicamente acomoda el Arreglo con el Método de la Burbuja llamando a otra serie de
Métodos.
Algoritmos:
Insertar(Arbol, N, Elemento)
Si N<25
Arbol[N] -> a
N -> N + 1
OrdMon(Arbol, N)
Salir
//Fin de la condición//
Imprimir "Árbol Lleno..."
Salir
OrdMon(Arbol, Total)
ConstMon(Arbol, Total)
Mientras Total > 1
Total -> Total - 1
Burbuja(0, Total)
RecMon(Total, 0)
//Fin del ciclo//
Salir
ConstMon(Arbol, Total)
v -> (Total/2) - 1
Página 25
ESTRUCTURA DE DATOS ITP
Mientras v ≥ 0
RecMon(Arbol, Total, v)
v -> v - 1
//Fin del ciclo//
Salir
----
RecMon(Arbol, Total, v)
w -> 2*v+1
Mientras w < Total
Si (w+1) < Total
Si Arbol[w+1] > Arbol[w]
w++
//Fin de la condición//
Fin de la condición
Si Arbol[v] ≥ Arbol[w]
Salir
//Fin de la condición//
Burbuja(Arbol, v, w)
v -> w
w -> 2*v+1
//Fin del ciclo//
Salir
----
Burbuja(Arbol, v, w)
t -> Arbol[v]
Arbol[v] -> Arbol[w]
Arbol[w] -> t
Salir
Diagrama:
Búsqueda
Definición:
Página 26
ESTRUCTURA DE DATOS ITP
Detalle:
Se manda al Método Búsqueda el Dato que se desea buscar, se acomoda el Árbol en Orden en
caso que no estuviera Ordenado y después compara con cada uno de los datos.
Algoritmos:
**Busqueda(Arbol, N, Elemento)**
Si N ≠ 0
OrdMon(Arbol, N)
i ->
Mientras i < N;i++)
Si Arbol[i] = Elemento
Imprimir "Elemento Encontrado..."
Salir
//Fin de la condición//
i -> i + 1
//Fin del ciclo//
Imprimir "El Elemento no esta en el Árbol..."
Salir
//Fin de la condición//
Imprimir "Árbol Vació..."
Salir
Diagrama:
Eliminación
Definición:
Página 27
ESTRUCTURA DE DATOS ITP
Detalle:
Vemos si el Árbol tiene Elementos insertados en el, de otra forma será imposible realizar la
Eliminación ya que esta Vació. Después si el Árbol tiene Elementos lo ordenamos y hacemos un
búsqueda lineal para encontrar el dato. Después usamos el método de la Burbuja para dejar el
Elemento Eliminado hasta el final y le Restamos a N un Elemento.
Algoritmo:
Eliminar(Arbol, N, Elemento)
Si N ≠ 0
OrdMon(Arbol, N)
i ->
Mientras I < N
Si Arbol[i] = Elemento
j -> i + 1
Mientras j < N
t -> Arbol[i]
Arbol[i] -> Arbol[j]
Arbol[j] -> t
j -> j + 1
//Fin del ciclo//
N -> n - 1
Imprimir "Elemento Eliminado..."
Salir
//Fin de la condición//
i -> i + 1
//Fin del ciclo//
Fin de la condición
Imprimir "Arbol Vacio... Imposible Eliminar..."
Salir
Diagrama:
Recorrido (Ordenado)
Definición:
Página 28
ESTRUCTURA DE DATOS ITP
Detalle:
Comparamos para comprobar que el Árbol tiene Elementos dentro de el, de ser así Desplegamos
cada uno de ellos. De otra manera Desplegamos Árbol Vació.
Algoritmo:
Recorrido (Arbol, N)
Si N ≠ 0
i ->
Mientras i < N
Imprimir Arbol[i]
i -> i + 1
//Fin del ciclo//
Salir
//Fin de la condición//
Imprimir "Arbol Vacio..."
Salir
Página 29
ESTRUCTURA DE DATOS ITP
• HIJO IZQUIERDO<RAIZ
• HIJO DERECHO<RAIZ
SEGUNDO PASO
GG
CUARTO PASO
TERCER PASO
Página 30
ESTRUCTURA DE DATOS ITP
• RAIZ<HIJO DERECHO
• RAIZ<HIJO IZQUIERDO
SEGUNDO PASO
ULTIMO PASO
Códigos
Árbol binario
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
struct nodo {
int nummat;
char nombre [ 3 O ] ;
struct nodo *izda, *dcha;
};
Página 31
ESTRUCTURA DE DATOS ITP
Página 32
ESTRUCTURA DE DATOS ITP
Nodo * t ;
t = (Nodo") malloc(sizeof(Nodo));
t -> nummat = id;
strcpy(t->nombre,n);
t -> izda = t-> dcha = NULL;
return t ;
}
Nodo* buscar (Nodo* p, int buscado)
if ( ! p )
else if (buscado == p -> nummat)
return p;
else if (buscado < p -> nummat)
return buscar (p -> izda, buscado);
else
return buscar (p -> dcha, buscado);
}
void insertar (Nodo** raiz, int nuevomat, char *nuevo-nombre)
i
if ( ! ("raiz))
*raiz = CrearNodo(nuevomat, nuevo-nombre);
else if (nuevomat i (*raiz) -> nummat)
insertar (&((*raiz) -> izda), nuevomat, nuevo-nombre);
else
Página 33
ESTRUCTURA DE DATOS ITP
En java
import java.awt.Color;
import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.TextArea;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
Página 34
ESTRUCTURA DE DATOS ITP
import javax.swing.*;
Container c=getContentPane();
private JMenuBar menu;
private JMenu i1,i2;
private JMenuItem construye,mostrar,alt,hoj,anc,salir,creditos,nuevo,inor,pos,pre;
private int dato=0,nodos=0;
Arbol arbol;
String aux="R",fila=" ",columna=" ",cadena=new String();
private TextArea most;
Página 35
ESTRUCTURA DE DATOS ITP
i2.add(inor);
i2.add(pos);
i2.add(pre);
nuevo.addActionListener(new manejaEventos());
salir.addActionListener(new manejaEventos());
mostrar.addActionListener(new manejaEventos());
construye.addActionListener(new manejaEventos());
alt.addActionListener(new manejaEventos());
anc.addActionListener(new manejaEventos());
hoj.addActionListener(new manejaEventos());
inor.addActionListener(new manejaEventos());
pre.addActionListener(new manejaEventos());
pos.addActionListener(new manejaEventos());
creditos.addActionListener(new manejaEventos());
menu.add(i1);
menu.add(i2);
c.setBackground(new Color(128,0,255));
setJMenuBar(menu);
if(e.getSource()==construye){
arbol=new Arbol();
int valor=0;
nodos=Integer.parseInt( JOptionPane.showInputDialog(null,"ingrese el numero de nodos para el
arbol") );
Página 36
ESTRUCTURA DE DATOS ITP
if(e.getSource()==pre){
JOptionPane.showMessageDialog(null,"Preorden : "+arbol.preorden());
}//end preorden
if(e.getSource()==inor){
JOptionPane.showMessageDialog(null,"Inorden : "+arbol.inorden());
}//end inorden
if(e.getSource()==pos){
JOptionPane.showMessageDialog(null,"Posorden : "+arbol.posorden());
}//end posorden
if(e.getSource()==alt){
JOptionPane.showMessageDialog(null,"Altura : "+arbol.altura(arbol.retornaraiz()));
}//end altura
if(e.getSource()==hoj){
JOptionPane.showMessageDialog(null,"Hojas : "+arbol.hojas(arbol.retornaraiz()));
}//end hojas
if(e.getSource()==anc){
int db=Integer.parseInt(JOptionPane.showInputDialog(null,"Ingrese el dato cuyos ancestros desea
conocer"));
JOptionPane.showMessageDialog(null,"Ancestro : "+arbol.ancestros(arbol.retornaraiz(),db));
}//end ancestros
if(e.getSource()==mostrar){
mostrarArbol(arbol.retornaraiz(),aux);
c.removeAll();
c.add(most);
c.setBackground(Color.WHITE);
c.repaint();
Página 37
ESTRUCTURA DE DATOS ITP
}//end mostrar
if(e.getSource()==nuevo){
c.removeAll();
arbol=new Arbol();
cadena=new String();
most=new TextArea();
dato=0;nodos=0;
aux="R";fila=" ";columna=" ";
c.setBackground(Color.WHITE);
}//end nuevo
if(e.getSource()==creditos){
c.removeAll();
JLabel cred=new JLabel("ESTE PROGRAMA FUE DISEÑADO POR JUAN RICARDO COGOLLO
OYOLA");
cred.setBounds(###TELEFONO_CENSURADO###);
cred.setFont(new Font("EuropeExt", Font.BOLD + Font.ITALIC, 14));
cred.setForeground(Color.DARK_GRAY);
c.setBackground(Color.white);
c.add(cred);
c.repaint();
}
if(e.getSource()==salir){
System.exit(0);
}//end salir
}}
Página 38
ESTRUCTURA DE DATOS ITP
if(R.li!=null){
aux="Izq";
fila=fila+" ";
mostrarArbol(R.li,aux);
int n=fila.length();
fila=fila.substring(10);
}
if(R.ld!=null){
aux="Der";
fila=fila+" ";
mostrarArbol(R.ld,aux);
int n=fila.length();
fila=fila.substring(10);
}
}
}//end windows
Árbol en montón
Página 39
ESTRUCTURA DE DATOS ITP
#include <conio.h>
#include <iostream.h>
class Arbol_Monton
private:
int Arbol[25];
int N;
public:
Arbol_Monton()
for(int i=0;i<25;i++)
Arbol[i]=0;
N=0;
void Insertar(int a)
if(N<25)
Arbol[N]=a;
N++;
OrdMon(N);
return;
Página 40
ESTRUCTURA DE DATOS ITP
cout<<"Arbol Lleno..."<<endl;
void Eliminar(int a)
int t;
if(N!=0)
OrdMon(N);
for(int i=0;i<N;i++)
if(Arbol[i]==a)
for(int j=i+1;j<N;j++)
t=Arbol[i];
Arbol[i]=Arbol[j];
Arbol[j]=t;
N--;
cout<<"Elemento Eliminado..."<<endl;
Página 41
ESTRUCTURA DE DATOS ITP
return;
void Busqueda(int a)
if(N!=0)
OrdMon(N);
for(int i=0;i<N;i++)
if(Arbol[i]==a)
cout<<"Elemento Encontrado..."<<endl;
return;
return;
cout<<"Arbol Vacio..."<<endl;
Página 42
ESTRUCTURA DE DATOS ITP
void OrdMon(int n)
ConstMon(n);
while(n>1)
n--;
Burbuja(0,n);
RecMon(n,0);
void ConstMon(int n)
for(int v=n/2-1;v>=0;v--)
RecMon(n,v);
int w=2*v+1;
while(w<n)
if(w+1<n)
Página 43
ESTRUCTURA DE DATOS ITP
if (Arbol[w+1]>Arbol[w])
w++;
if(Arbol[v]>=Arbol[w])
return;
Burbuja(v,w);
v=w;
w=2*v+1;
int t=Arbol[i];
Arbol[i]=Arbol[j];
Arbol[j]=t;
void Recorrido()
if(N!=0)
for(int i=0;i<N;i++)
cout<<Arbol[i]<<endl;
return;
Página 44
ESTRUCTURA DE DATOS ITP
cout<<"Arbol Vacio..."<<endl;
}tec;
main()
int res,op=0;
while(op!=5)
clrscr();
gotoxy(1,1);
cin>>op;
gotoxy(1,10);
switch (op)
case 1:
tec.Recorrido();
break;
case 2:
Página 45
ESTRUCTURA DE DATOS ITP
cin>>res;
tec.Busqueda(res);
break;
case 3:
cin>>res;
tec.Insertar(res);
break;
case 4:
cin>>res;
tec.Eliminar(res);
break;
case 5:
cout<<"Salida...";
break;
default:
cout<<"Opcion Erronea"<<endl;
break;
getch();
Página 46
ESTRUCTURA DE DATOS ITP
Página 47