aplicaciones de arboles

TEMA

UNIVERSIDAD NACIONAL

MICAELA BASTIDAS DE APURIMAC

FACULTAD DE INGENIERIA

CARRERA PROFESIONAL DE

INGENIERIA INFORMATICA Y SISTEMAS

ASIGNATURA

: ALGORITMICA II

DOCENTE : Ing. FRANCISCO CARI I.

INTEGRANTES :

Taipe Condori Yadhira Y.

Velásquez Diaz Felix F.

ZuzunagaMoreano Michael W.

Lizonde Espinoza Jenry

Huancacuri flores adolfo

Abancay – Apurímac

2011

Aplicaciones de arboles

“UNIVERSIDAD NACIONAL MICAELA BASTIDAS DE APURIMAC” Escuela Académica Profesional Ingeniería Informática y Sistemas

DEDICATORIA

Este trabajo monográfico ha sido realizado con mucho esmero y dedicación, para poder aprender y poder dar a conocer a los demás del tema de árboles y sus aplicaciones.Esperandoque sea de su agrado y entendible para los demás.

Página 2


Introducción

El siguiente trabajo trata sobre la estructura de datos no lineales llamada árbol. Esta

estructura se usa principalmente para representar datos con una relación jerárquica entre sus

elementos, como por ejemplo registros, árboles genealógicos y tablas de contenidos.

También se va a ampliar sobre árboles más generales y puntos con relación a los árboles

binarios.

Pero vamos a centrarnos en las aplicaciones de los árboles, la cual puede ser implementado

fácilmente en la computadora y estas aplicaciones van a ser representaciones de

Página 3


Página 4


INDICECAPITULO I1.- Arboles………………………………………………………………………………………………………………………………………31.1.- Componentes de un árbol………………………………………………………………………………………………………41.2.- Características y propiedades de los arboles……………………………………………………………………4 - Orden - Grado - Nivel - Altura1.3.- Clasificación de árboles…………………………………………………………………………………………………………4CAPITULO II2.- Arboles binarios……………………………………………………………………………………………………………………………52.1.- Tipos de árboles binarios…………………………………………………………………………………………………………52.2.- Arboles binarios completos……………………………………………………………………………………………………52.3.- Árbol binario de búsqueda………………………………………………………………………………………………………63.- Tipos de recorrido sobre arboles………………………………………………………………………………………………63.1.- Recorrido en profundidad…………………………………………………………………………………………………………6 3.1.1.- Pre orden……………………………………………………………………………………………………………………………………7

Página 5


3.1.2.- Post

orden…………………………………………………………………………………………………………………………………8 3.1.3.- In orden……………………………………………………………………………………………………………………………………93.2.- Recorridos de amplitud…………………………………………………………………………………………………………103.3.- Características y utilidades de los recorridos……………………………………………………………………10 - Insertar……………………………………………………………………………………………………………………………………………10 - Eliminación………………………………………………………………………………………………………………………………………11 - Nivel de un árbol……………………………………………………………………………………………………………………………134.- Codificación en c++………………………………………………………………………………………………………………………155.- Aplicaciones de árboles……………………………………………………………………………………………………………Conclusion…………………………………………………………………………………………………………………………………………………

Árboles

Es una estructura de datos no lineal que posee raíz, ramas y hojas, técnicamente constituye un grafo finito y sin ciclos. En los árboles los datos se organizan de forma jerárquica, cada elemento recibe el nombre de nodo y el cual dependerá jerárquicamente de otro nodo llamado padre.Los nodos que dependen de un nodo dado se llaman “nodos hijos”, en donde las hojas constituyen el nivel más bajo.

Página 6


Ejemplo árbol:

Componentes del árbol :

Raíz: En todo el árbol existe un nodo especial que no tiene padre y del cual parte toda la estructura jerárquica, a este nodo se le denomina raíz del árbol.

Padre: Predecesor máximo de un nodo.

Hijo: Cualquiera de los sucesores directos de un nodo,se encuentra enlazado a otro nodo. Hermano: Cualquier otro nodo hijo de un mismo padre. Hojas: son aquellos nodos que no tienen hijos. En un árbol solo puede haber una raíz pero pueden

haber muchas hojas. Subárbol:Cualquier nodo se puede considerar como la raíz de un subárbol.

Hermanos

Subárbol

Página 7


Altura de un nodo:en un árbol es el número de nodos del camino más largo de ese nodo a una hoja.

Grado de un nodo: Se denomina al número de hijos de dicho nodo. Grado de un árbol :Es el mayor grado de los nodos que contiene. Ramas: Conexión entre dos nodos del árbol que representa una relación de jerarquía.

Existen otros conceptos que definen las características del árbol, en relación a su tamaño:

Orden: es el número potencial de hijos que puede tener cada elemento de árbol. De este modo, diremos que un árbol en el que cada nodo puede apuntar a otros dos es de ordendos, si puede apuntar a tres será de orden tres, etc.

Grado: el número de hijos que tiene el elemento con más hijos dentro del árbol. Nivel: se define para cada elemento del árbol como la distancia a la raíz, medida en nodos. El nivel de la raíz es cero y el de sus hijos uno. Altura: la altura de un árbol se define como el nivel del nodo de mayor nivel. Como cada

nodo de un árbol puede considerarse a su vez como la raíz de un árbol.CLASIFICACIÓNDE ÁRBOLES

Árbol Binario de Búsqueda (ABB): Donde todos los nodos tienen como máximo dos hijos.

Árboles Ordenados: Los árboles ordenados (denominados B-trees). Esto significa que para su construcción, los nodos que se van agregando no se colocan al azar, colgando de cualquier nodo existente, sino según un criterio que tiene en consideración el "valor" de la hoja. Este tipo de estructura se usa extensivamente en las bases de datos y en los sistemas de ficheros.

CAPÌTULO II

2.ÁRBOLES BINARIOS

En ciencias de la computación, un árbol binario es una estructura de datos en la cual cada nodo siempre tiene un hijo izquierdo y un hijo derecho. No pueden tener más de dos hijos (de ahí el nombre "binario"). Si algún hijo tiene como referencia a null, es decir que no almacena ningún dato, entonces este es llamado un nodo externo. En el caso contrario el hijo es llamado un nodo interno.

2.1. Tipos de árboles binarios

Un árbol binario es un árbol con raíz en el que cada nodo tiene como máximo dos hijos. Un árbol binario lleno es un árbol en el que cada nodo tiene cero o dos hijos. Un árbol binario perfecto es un árbol binario lleno en el que todas las hojas (vértices con cero hijos)

están a la misma profundidad (distancia desde la raíz, también llamada altura)

Página 8


A veces un árbol binario perfecto es denominado árbol binario completo. Otros definen un árbol binario completo como un árbol binario lleno en el que todas las hojas están a profundidad n o n-1, para alguna n.

(1) A

B

E D

F

Cualquier nodo N de un árbol binario T tiene 0, 1 ó 2 sucesores. De (1) Los nodos A,B,C y H tienen dos sucesores, los nodos R y J sólo tienen un sucesor , y los nodos D,F, G,L y K no tienen sucesores. Los nodos sin sucesores se llaman nodos terminales.

2.1.1.Árboles binarios Completos. Considere un árbol binario T. El árbol binario T se dice que es completo si todos sus niveles, excepto posiblemente el ultimo, tienen el máximo numero de nodos posibles y si todos los nodos del ultimo nivel están situados. Lo más posible a la izquierda. Así, solo existe un único árbol completo Tn con exactamente n nodos.

Estructura tipo Árbol de grado dos (binario completo):

(1)

D

A

CB

ED

F

GH

K

L

J

A

CB

ED G

H

Página 9


Árbol binario de Búsqueda

(1)

D

Tipos De Recorrido Sobre Árboles.

Recorridos en Profundidad: Se alejan cuanto antes de la raíz.El método de este recorrido es tratar de encontrar de la cabecera a la raíz en nodo de unidad binaria Ahora pasamos a ver la implementación de los distintos recorridos:

Preorden:En este tipo de recorrido se realiza cierta acción (quizás simplemente imprimir por pantalla el valor de la clave de ese nodo) se basa en visitar lo siguiente:

Primero Visitar la raíz, luego se visita el subárbol o hijoizquierdo y concluyendo se pasaal subárbolo hijo derecho.

1.-Sea el ejemplo: 14, 16, 4, 3, 15, 9,18

(1)

5

KJ

83

41 6

9

14

16Página 10


B

D

Raiz, Hijo izquierdo, hijo derecho

Recorrido en preorden 14, 4, 3, 9, 16, 15,18

2.- ejemplo: 16, 5, 26, 1, 17, 30, 10, 9

(1)

B

D

Recorrido preorden: 16 -5-1 -17-26-30-10-9.

Algoritmo de preorden en c++:

void preorden(NODOARBOL *cabeza){

if(cabeza!=NULL) {

cout<<" "<< cabeza->dato;preorden(cabeza->izq);preorden(cabeza->der);

}}

4

93 15 18

16

265

171 3010

9

Página 11


2.2.1.2. Postorden:

En este caso se trata primero de búsqueda se visita primero el subárbol izquierdo y concluyendo este, se visita el derecho y por último la raíz.

Ejemplo:

(1)

B

D

Hijo izquierdo, hijo derecho, padre Recorrido postorden :1-17-5-9-10-30-26-16

Algoritmo de postorden en c++:

voidposorden(NODOARBOL *cabeza){

if(cabeza!=NULL) {

posorden(cabeza->izq);posorden(cabeza->der);cout<<" "<<cabeza->dato; }

}

2.2.1.3. Inorden(entreorden):

En este caso se trata primero el subárbol izquierdo, después la raiz y por último el subárbol derecho. En un ABB este recorrido daría los valores de clave ordenados de menor a mayor.

Ejemplo:

16

265

171 3010

Página 12


(1)

B

D

Hijo izquierdo, padre, hijo derecho Recorrido inorden:1-5-17-16-30-26-10.

Pseudocódigo:funcioninorden(nodo)iniciosi(existe(nodo))inicioinorden(hijo_izquierdo(nodo));tratar(nodo); //Realiza una operación en nodoinorden(hijo_derecho(nodo));fin;fin;

Algoritmo de inorden en c++:

voidinorden(NODOARBOL *cabeza){if(cabeza!=NULL) {

inorden(cabeza->izq);cout<<" "<<cabeza->dato;inorden(cabeza->der);

}}

Recorridos en Amplitud: trata consecutivamente los nodos que se encuentran al mismo nivel.

En este caso el recorrido se realiza en orden por los distintos niveles del árbol. Así, se comenzaría tratando el nivel 1, que sólo contiene el nodo raíz, seguidamente el nivel 2, el 3 y así sucesivamente.

Características y Utilidades de los Recorridos.

16

265

171 30

10

Página 13


PREORDEN: Se va a utilizar siempre que queramos comprobar alguna propiedad del árbol ( p.ej.: localizar elementos ).

INORDEN: Se utiliza siempre que nos pidan algo relativo a la posición relativa de las claves o algo que tenga que ver con el orden de las claves ( p.ej.: ¿Cuál es la 3ª clave?).

POSTORDEN: Se utiliza poco. Su principal utilidad consiste en liberar la memoria ocupada por un árbol.

AMPLITUD: Se utiliza siempre que nos pidan operaciones cuyo tratamiento se haga por niveles.

INSERTAR

Se deben declara dos argumentos, un puntero al raíz del árbol y el dato que tendrá el nodo. La función dos argumentos un puntero al raíz del árbol u el dato que tendrá el nodo. La función creara un nuevo nodo y lo insertara en el lugar correcto en el árbol de modo que el árbol permanezca como binario búsqueda.La operación de inserción de in nodo es una extensión de la operación de búsqueda, los pasos a seguir son:

Asignar memoria para un nueva estructura nodo. Buscar en el árbol para encontrar la posición de inserción del nuevo nodo, que se colocara

como nodo hoja. Enlazar un nuevo nodo al árbol.

Ejemplos:

Página 14

17

309

14 4

18

3 9

16

4

183

9 16

15


void Insertar(nodo Arbol,intelem){nodoaux=Arbol;

if(Arbol==NULL){

Arbol=(nodo)malloc(sizeof(structnodo_arbol));//crea un //espario de memoria para el nodo.

if(Arbol==NULL)printf("No hay Memoria");

(Arbol)->dato=elem;(Arbol)->izq=NULL;(Arbol)->der=NULL;

}else if(elem<=aux->dato)

Arbol->izq=Insertar(aux->izq,elem);else if(elem>aux->dato)

Arbol->der=Insertar(aux->der,elem);else

printf(" Error !");returnArbol;

}

ELIMINACION

La operación de eliminación de un nodo es también una extensión de la operación de búsqueda, si bien más compleja que la inserción debido a que el nodo a suprimir puede ser cualquiera y la operación de supresión debe mantener la estructura de árbol binario de búsqueda después de la eliminación.

Si el nodo a eliminar es un:

Página 15

13

2125 40


Nodo hoja Buscar el Nodo Padre del nodo a borrar. Desconectarlo. Liberar el nodo.

Nodo con un hijo

Buscar el Nodo Padre del nodo a borrar. Conectar el hijo con el padre del nodo a borrar. Liberar el nodo.

Nodo con dos hijos

Localizar el nodo predecesor o sucesor del nodo a borrar. Copiar la información. Eliminar el predecesor o sucesor según sea el caso.

Ejemplo: deseamos eliminar nodo 25:

VoidEliminar(nodo cabeza, int elemento){

nodotemp=cabeza;if(elemento<cabeza->dato)

cabeza->izq=Eliminar(cabeza->izq,elemento);elseif(elemento>cabeza->dato)

cabeza->der=Eliminar(cabeza->der,elemento);else{

if(temp->izq==NULL)cabeza=temp->der;

else if(temp->der==NULL)cabeza=temp->izq;

if(temp->der!=NULL&&temp->izq!=NULL)temp=reemplazar(temp);

free(temp);

Página 16


}return cabeza;

}

ALTURA. -Es la longitud del camino más largo desde la raíz hasta una hoja.

Su código esta aquí:

int Altura(nodo Arbol){int x=0,y=0;

if(Arbol->izq!=NULL) x=Altura(Arbol->izq)+x+1;if(Arbol->der!=NULL) y=Altura(Arbol->der)+y+1;if(x>y)return x;elsereturn y;

}

NIVEL DE UN ARBOL.-

• 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.

El nivel de este árbol es 2. El nivel de la raiz es 0.

Aquí apreciamos el código en c++ de nivel de un árbol:

void nivel(nodo Arbol1,int elem)

{int m=0;nodoArbol=Arbol1;if(Arbol!=NULL) {

if(Buscar(Arbol,elem)==1) {

Página 17


while((Arbol!=NULL)&&(Arbol->dato!=elem)) {if(Arbol->dato<elem)

Arbol=Arbol->der;if(Arbol->dato>elem)Arbol=Arbol->izq;

m=m+1; }if (Arbol->dato==elem)

cout<<elem<<"-- nivel --"<<m;}

elsecout<<"No existe";

} elsecout<<"Arbolvacio"; }

Hijos.-

Son también nodos conectados a otro nodos llamados padres también de les dice hijos

nodos, puede estar en diferentes niveles del árbol un padre nodo también puede ser un hijo

nodo.Todos los nodos conectados a un nodo concreto son hijos o bien el padre de dicho

nodo.

Aquí se puede apreciar el código en c++ de hijo en un árbol:

void hijo(nodo Arbol1)

{

nodoaux,tem,Arbol=Arbol1;

if(Arbol!=NULL)

{

if((Arbol->izq!=NULL)||(Arbol->der!=NULL))

{

if((Arbol->izq!=NULL)&&(Arbol->der!=NULL))

Página 18


{

aux=Arbol;

tem=Arbol;

tem=tem->der;

aux=aux->izq;

cout<<"\n\nPadre: "<<Arbol->dato;

cout<<"\nHijos: "<<tem->dato<<aux->dato;

printf(" %d",aux->dato);

}

if((Arbol->izq!=NULL)&&(Arbol->der==NULL))

{

aux=Arbol;

aux=Arbol->izq;

printf("\n Un Padre es :%d ",Arbol->dato);

printf(" y su unico hijo es: %d ",aux->dato);

}

if((Arbol->izq==NULL)&&(Arbol->der!=NULL))

{

aux=Arbol;

tem=tem->der;


printf(" no tiene hijos: %d ",Arbol->dato);

}

}

hijo(Arbol->izq);

hijo(Arbol->der);

}

else

printf("\n no existe arbol ingrese nodos");

}

Aquí se muestra el código de hojas en un arbol:

Página 19


void hojas(nodo Arbol) {nodo aux=Arbol;if(aux->izq==NULL&&aux->der==NULL)

cout<<aux->dato<<",";else {if(aux->izq!=NULL)

hojas(aux->izq);if(aux->der!=NULL)

hojas(aux->der); } }Códigos de las búsquedas de postorden,preorden,inordenvoidpostorden(arbol *a){if (a != NULL) {postorden(a->izq);postorden(a->der);visitar(a); }}voidIn_Orden(Arbol a) { if(a == NULL) return; RecorrerArbol(a->rama[0]); Procesar(dato); RecorrerArbol(a->rama[1]); RecorrerArbol(a->rama[2]); }

Buscar un elemento .-

Partiendo siempre del nodo raíz, el modo de buscar un elemento se define de forma recursiva.

• Si el árbol está vacío, terminamos la búsqueda: el elemento no está en el árbol. • Si el valor del nodo raíz es igual que el del elemento que buscamos, terminamos la

búsqueda con éxito. • Si el valor del nodo raíz es mayor que el elemento que buscamos, continuaremos la

búsqueda en el árbol izquierdo. • Si el valor del nodo raíz es menor que el elemento que buscamos, continuaremos la

búsqueda en el árbol derecho.

El valor de retorno de una función de búsqueda en un ABB puede ser un puntero al nodo encontrado, o NULL, si no se ha encontrado.

Página 20


/*BUSCA UN ELEMENTO*/

int Buscar(nodo Arbol,intelem){if(Arbol!=NULL) {if(Arbol->dato==elem)

return 1;else

{if(elem<Arbol->dato)

Buscar(Arbol->izq,elem);else

{if(elem>Arbol->dato)

Buscar(Arbol->der,elem); } } }elsereturn 0;}

CODIGO FUENTE EN C++ DE ARBOLES

#include<iostream.h>#include<conio.h>#include<stdio.h>#include<stdlib.h>#include <dos.h>#include<math.h>#include<graphics.h>

structnodo_arbol{intdato;nodo_arbol *izq;nodo_arbol *der; };typedefnodo_arbol *nodo;//----------------------------------------------------------------------------//intBuscar(nodoArbol,intelem);intcx,cy,pf,ax,rd=13;

//----------------------------------------------------------------------------//

Página 21


char *Opciones[]={"[1] Inicializar","[2] Insertar","[3] Eliminar",

"[4] Graficar","[5] Altura","[6] Nivel","[7] Cantidad Nodos","[8] Hijo-Padre","[9] Hijos","[10] Hojas","[11] Pre-Orden","[12] Post-Orden","[13] In-Orden","[14] Buscar","[0] Salir"};

void menu() {setfillstyle(1,0);bar(0,500,650,10);

for(int i=0;i<15;i++)cout<<"\n"<<Opciones[i];

}//----------------------------------------------------------------------------//

nodo inicializar(nodo Arbol) {

Arbol=NULL;returnArbol;

}//----------------------------------------------------------------------------//

nodo Insertar(nodo Arbol,intelem){nodoaux=Arbol;

if(Arbol==NULL){Arbol=(nodo)malloc(sizeof(structnodo_arbol));if(Arbol==NULL)

printf("No hay Memoria");(Arbol)->dato=elem;(Arbol)->izq=NULL;(Arbol)->der=NULL;

}else if(elem<=aux->dato)

Arbol->izq=Insertar(aux->izq,elem);else if(elem>aux->dato)

Arbol->der=Insertar(aux->der,elem);else

printf(" Error !");

Página 22


returnArbol;}

//----------------------------------------------------------------------------//nodo reemplazar(nodo cabeza){

nodoaux,temp;temp=cabeza;aux=cabeza->izq;while(aux->der!=NULL)

{temp=aux;aux=aux->der;

}cabeza->dato=aux->dato;if(temp==cabeza)

temp->izq=aux->izq;else

temp->der=aux->izq;cabeza=aux;

return cabeza;}

nodo Eliminar(nodo cabeza, int elemento){

nodotemp=cabeza;if(elemento<cabeza->dato)

cabeza->izq=Eliminar(cabeza->izq,elemento);elseif(elemento>cabeza->dato)

cabeza->der=Eliminar(cabeza->der,elemento);else{

if(temp->izq==NULL)cabeza=temp->der;

else if(temp->der==NULL)cabeza=temp->izq;

if(temp->der!=NULL&&temp->izq!=NULL)temp=reemplazar(temp);

free(temp);}

return cabeza;}

//----------------------------------------------------------------------------//voidPre_Orden(nodo Arbol){

if(Arbol!=NULL){

cout<<Arbol->dato<<",";

Pre_Orden(Arbol->izq);

Página 23


Pre_Orden(Arbol->der);}}

//----------------------------------------------------------------------------//voidIn_Orden(nodo Arbol){

if(Arbol!=NULL){

In_Orden(Arbol->izq);cout<<Arbol->dato<<",";In_Orden(Arbol->der);

}}

//----------------------------------------------------------------------------//voidPost_Orden(nodo Arbol){

if(Arbol!=NULL){

Post_Orden(Arbol->izq);Post_Orden(Arbol->der);printf("%d,",Arbol->dato);

}}

//----------------------------------------------------------------------------//intCantidadNodos(nodo Arbol){int x=0;

if(Arbol->izq!=NULL)x=CantidadNodos(Arbol->izq)+x+1;if(Arbol->der!=NULL)x=CantidadNodos(Arbol->der)+x+1;

return x;}

//----------------------------------------------------------------------------//int Altura(nodo Arbol){int x=0,y=0;

if(Arbol->izq!=NULL)x=Altura(Arbol->izq)+x+1;if(Arbol->der!=NULL)y=Altura(Arbol->der)+y+1;if(x>y)return x;elsereturn y;

}

//----------------------------------------------------------------------------//

Página 24


voidDibujar(nodo Arbol1,int a,intb,intc,int d){

//========================= // para graficar el margencx=getmaxx(),cy=getmaxy(); //Coordenadas maximas en X Ysetcolor(15);setlinestyle(0,0,1);line(0,0,cx,0); //Line grafica coordenadas desde laline(cx,0,cx,cy); //la posicion inicial (cx,0) hastaline(cx,cy,0,cy); //la posicion final (0,cy), asi esline(0,cy,0,0); //para todas las lineasline(4,4,cx-4,4);line(cx-4,4,cx-4,cy-4);line(cx-4,cy-4,4,cy-4);line(4,cy-4,4,4);setcolor(GREEN); //Se establece el color de la lineasetlinestyle(0,0,3); //Se establece el estilo de la linealine(2,2,cx-2,2);line(cx-2,2,cx-2,cy-2);line(cx-2,cy-2,2,cy-2);line(2,cy-2,2,2);

//==================================charvalue[3];nodoArbol=Arbol1;if(Arbol!=NULL){itoa(Arbol->dato,value,10);circle(300+a,75+b,14);setcolor(12);outtextxy(295+a,75+b,value);setcolor(WHITE);if(d==1)

line(300+a+pow(2,c+1),b+14,300+a,61+b);else if(d==2)

line(300+a-pow(2,c+1),b+14,300+a,61+b);setcolor(12);settextstyle(1,0,1); Dibujar(Arbol->izq,a-pow(2,c)-pow(2,d-4),b+75,c-

1,1);Dibujar(Arbol->der,a+pow(2,c)+pow(2,d-4),b+75,c-1,2);

}}

//----------------------------------------------------------------------------//nodoHijoPadre(nodo Arbol1,int num){

nodo_arbol *Arbol=Arbol1;if(Arbol->dato==num)

cout<<"La raiz no tiene padre";else if(num==Arbol->izq->dato)

printf("El Padre es:_%d",Arbol->dato);

Página 25


else if(num==Arbol->der->dato)printf("El Padre es:_%d",Arbol->dato);

else if(num<Arbol->dato)Arbol->izq=HijoPadre(Arbol->izq,num);else if(num>Arbol->dato)Arbol->der=HijoPadre(Arbol->der,num);returnArbol;

}//----------------------------------------------------------------------------//

intBuscar(nodo Arbol1,int elem){

nodoArbol=Arbol1;if(Arbol!=NULL)

{if(Arbol->dato==elem)

return 1;else if(elem<Arbol->dato)

Buscar(Arbol->izq,elem);else if(elem>Arbol->dato)

Buscar(Arbol->der,elem);}

elsereturn 0;

}//----------------------------------------------------------------------------//

void hijo(nodo Arbol1) {

nodoaux,tem,Arbol=Arbol1;if(Arbol!=NULL){

if((Arbol->izq!=NULL)||(Arbol->der!=NULL)){

if((Arbol->izq!=NULL)&&(Arbol->der!=NULL)){

aux=Arbol;tem=Arbol;tem=tem->der;aux=aux->izq;cout<<"\n\nPadre: "<<Arbol->dato;cout<<"\nHijos: "<<tem->dato<<aux->dato;printf(" %d",aux->dato);

}if((Arbol->izq!=NULL)&&(Arbol->der==NULL)){

aux=Arbol;aux=Arbol->izq;


Página 26


printf(" y su unico hijo es: %d ",aux->dato);}if((Arbol->izq==NULL)&&(Arbol->der!=NULL))

{aux=Arbol;tem=tem->der;printf("\n Un Padre es :%d ",Arbol->dato);printf(" no tiene hijos: %d ",Arbol->dato);

}}hijo(Arbol->izq);hijo(Arbol->der);

}else

printf("\n no existe arbol ingrese nodos");}

//----------------------------------------------------------------------------//void nivel(nodo Arbol1,int elem){

int m=0;nodoArbol=Arbol1;

if(Arbol!=NULL){

if(Buscar(Arbol,elem)==1){

while((Arbol!=NULL)&&(Arbol->dato!=elem)){

if(Arbol->dato<elem)Arbol=Arbol->der;

if(Arbol->dato>elem)Arbol=Arbol->izq;

m=m+1;}

if (Arbol->dato==elem)cout<<elem<<"-- nivel --"<<m;

}else

cout<<"No existe";}

elsecout<<"Arbolvacio";

}//----------------------------------------------------------------------------//void hojas(nodo Arbol)

{nodo aux=Arbol;

Página 27


if(aux->izq==NULL&&aux->der==NULL)cout<<aux->dato<<",";

else {if(aux->izq!=NULL)

hojas(aux->izq);if(aux->der!=NULL)

hojas(aux->der); } }

//----------------------------------------------------------------------------//void caratula(){int x=65,y=46;setcolor(6);settextstyle(1,0,3);outtextxy(x,y,"UNIVERSIDAD NACIONAL MICAELA BASTIDAS");setcolor(15);settextstyle(6,0,4); outtextxy(x+40,y+40,"ING: INFORMATICA Y SISTEMAS");settextstyle(1,0,2);setcolor(4);outtextxy(x+130,y+91,"ALGORITMICA II");setcolor(9);outtextxy(x+100,y+120,"Programacion en C++ ");

settextstyle(1,0,1);setcolor(8);settextstyle(1,0,2);setcolor(14); settextstyle(3,0,8);outtextxy(x+45,y+160,"ºARBOLESº");settextstyle(1,0,2);setcolor(WHITE); outtextxy(x+390,y+360," [*.!.*]->> MAMANI");while(!kbhit())

{setcolor(2);settextstyle(10,0,6);outtextxy(80,295,"BIENVENIDOS");settextstyle(1,0,3); }for (int i=0;i<8;i++){ printf("\n\n\n\n\n\n\n",i);}

getch(); }//====================================================================int inicializador(void) //Inicializa el Modo Grafico{

inti,controlador=DETECT,modo,error;

Página 28


initgraph(&controlador,&modo,"c:/bc5/bgi");error = graphresult();if (error != grOk)

{printf("Error en Modo Grafico: %s\n",grapherrormsg(error));printf("Presione una tecla para continuar:");getch();exit(1); //Si la inicializacion del Modo Grafico } //no tuvo exito, presenta un mensaje dereturn(0); //error.}//====================================================================void cerrar(){ //Para Cerrar el Modo Graficoclosegraph();}//====================================================================void fondo() //Este fondo dibuja pixeles aleatorios{ //en toda la pantalla

int cc;intx,y,i,color; //Se grafica el margen segun el color //Pixeles Aleatorios

setcolor(15);setlinestyle(0,0,1);line(0,0,cx,0); //Line grafica coordenadas desde laline(cx,0,cx,cy); //la posicion inicial (cx,0) hastaline(cx,cy,0,cy); //la posicion final (0,cy), asi esline(0,cy,0,0); //para todas las lineas

line(4,4,cx-4,4);line(cx-4,4,cx-4,cy-4);line(cx-4,cy-4,4,cy-4);line(4,cy-4,4,4);setcolor(4); //Se establece el color de la lineasetlinestyle(0,0,3); //Se establece el estilo de la linealine(2,2,cx-2,2);line(cx-2,2,cx-2,cy-2);line(cx-2,cy-2,2,cy-2);line(2,cy-2,2,2);

randomize();for (i=0;i<=2000;i++)

{ x=random(cx+1);

Página 29


y=random(cy+1);color=random(cc+1);putpixel(x,y,color);

delay(2); } //Se llama a la caratula de presentacion

//Se llama al margen a se le envia 6caratula(); //al color del filo intermedio} //de fino interno resivido

//====================================================================void gracias(){

setfillstyle(1,128);bar(22,0,616,470);setcolor(4);rectangle(22,0,616,470);rectangle(26,4,612,465);

for (int i=1;i<=3;i++) {setcolor(i); settextstyle(1,0,5); outtextxy(10*i+50,4*i+20, "INFORMATICA Y SISTEMAS"); }

setcolor(GREEN);settextstyle(4,0,6); outtextxy(80,70," ALGORITMICA II ");settextstyle(1,0,3);setcolor(9);settextstyle(1,0,4);outtextxy(50,170," ºProyecto Realizado de Arbolesº ");settextstyle(1,0,2);outtextxy(295,440,"Yonatan Mamanicoaquira");setcolor(7);settextstyle(1,0,1); outtextxy(200,410," Presione< Enter > Para SALIR...... ");

while(!kbhit()){setcolor(GREEN);settextstyle(10,0,6); outtextxy(80,280,"GRACIAS !!!");

settextstyle(1,0,3);}

getch();

for (int i=0;i<8;i++) {

Página 30


printf("\n\n\n\n\n\n\n",i);}

}

//======================================================

main(){

nodoArbol;intelem,op,num,a,Cantidad,existe;inicializador();cx=getmaxx(),cy=getmaxy(); //Coordenadas maximas en X Yfondo();while(1) {

menu();cout<<"\n\t\tOpcion: ";cin>>op;switch(op)

{case 1: clrscr();

Arbol=inicializar(Arbol);

break;case 2:

cout<<"\nElemento: ";cin>>elem;

Arbol=Insertar(Arbol,elem);

break;

case 3:cout<<"\nElemento: ";

cin>>num;if(Arbol==NULL)

cout<<"Arbolvacio";else {if(Buscar(Arbol,num)==1)

Arbol=Eliminar(Arbol,num);else

cout<<"El elto no existe el en Arbol";}

break;case 4:

cleardevice();Dibujar(Arbol,15,3,7,0);

break;

Página 31


case 5:a=Altura(Arbol);

cout<<"\nAltura: "<<(a+1);break;


cin>>elem;nivel(Arbol,elem);

break;case 7:

Cantidad=CantidadNodos(Arbol);cout<<"\nCntidad:"<<(Cantidad+1);break;


cin>>num;existe=Buscar(Arbol,num);

switch(existe){

case 1:Arbol=HijoPadre(Arbol,num);

break;case 0:

cout<<"El numero no existe en el arbol";break;

}break;

case 9:hijo(Arbol);

break;case 10:

if(Arbol==NULL)cout<<"Arbolvacio";

elsehojas(Arbol);

break;case 11:

cout<<"\n\t Pre-Orden: ";Pre_Orden(Arbol);

break;case 12:

cout<<"\n\t Post-Orden: ";Post_Orden(Arbol);

break;case 13:

cout<<"\n\t In-Orden: ";

In_Orden(Arbol);

Página 32


break;case 14:

cout<<"\nElemento:";cin>>elem;if(Buscar(Arbol,elem)==1)

cout<<"\n El nodo "<<elem<<" Existe:";else

cout<<"\n No Existe";break;

case 0: gracias();exit(0);

break;default:

cout<<"--- ERROR ---";break; }

getch();clrscr();

}closegraph();}

Uso de árboles en las decisiones El desarrollo de árboles de llevan a los analistas a identificar de manera formal las decisiones que actualmente deben tomarse. De esta forma, es difícil para ellos pasar por alto cualquier etapa del proceso de decisión. Los árboles indican los conjuntos de datos que la gerencia requiere para formular decisiones o tomar acciones. El analista debe identificar y elaborar una lista de todos los datos utilizados en el proceso de decisión.

Los árboles de decisión se construyen después de completar el análisis de flujo de datos. Si únicamente se usan árboles de decisiones, entonces el analista debe tener la certeza de identificar con precisión cada dato necesario para tomar la decisión. Desarrollo

Presentamos un árbol de decisión para un problema medico real que se presenta a diario en todos los hospitales del mundo y que se encuentra entre las primeras causas de morbilidad y muerte que constituye causa de invalidez e incapacidad física :el dolor precordial como síntoma de las enfermedades del corazón. El árbol nos permite tomar decisiones y llegar a una solución ante cada problema.

Página 33


Una aplicación para calcular los conjuntos de vértices resolutivos y la dimensión métrica de árboles.

Aplicación interactiva para la construcción de árboles generadores que optimizan varios criterios (peso, uniformidad y caminos de capacidad máxima).

Árbol generador mínimo Algoritmos de Prim y Kruskal.

El método de ordenamiento heapsort es también conocido con el nombre de montículo y es el método más eficiente de ordenamiento de los que trabajan con árboles

En las redes de comunicación emplean arboles.

Página 34


la inteligencia artificial realiza uso de los arboles.

Se aplica en las calculadoras con operaciones básicas y las científicas.

Se aplica en los celulares.

Página 35


Conclusión.

De este trabajo se podría decir que un árbol binario se define como un conjunto finito de

elementos llamados nodos. En estos casos se puede usar terminología de relaciones familiares

para descubrir las relaciones entre los nodos de un árbol; y que un árbol puede ser implementado

fácilmente en una computadora. Es bueno hacer énfasis en esto ya que se puede saber mucho

sobre lo que tiene que ver con los árboles; entre las cosas que podemos mencionar se encuentra

la raíz, los nodos de un árbol y la diferencia entre nodos sucesores y nodos terminales, como se

muestran en el contenido del trabajo.

Página 36

aplicaciones de arboles

Documents