El programa genera un arbol binario, captura caracteres y los introduce en el arbol, despues muestra los recorridos en preorden, inorden

y postorden. Maneja memoria dinamica!!!

//PROGRAMA QUE CAPTURA UNA CADENA DE CARACTERES DE MAXIMO 200 ELEMENTOS Y //CREA UN ARBOL DE BUSQUEDA CON LOS CARACTERES DE LA CADENA Y REALIZA RECORRIDOS // EN PREORDEN,ENTREORDEN Y POSTORDEN. #include<stdio.h> #include<conio.h> #include<stdlib.h> #include<string.h> /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/ struct nodoarbol{ //ESTRUCTURA DEL ARBOL struct nodoarbol *izqnodo; int info; struct nodoarbol *dernodo; }; typedef struct nodoarbol NODO; //DEFINICION DE TIPO NODO typedef NODO *ARBOL; //DECLARACION DE VARIABLE PUNTERO A NODO /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/ void insertanodonuevo(ARBOL *,int); //DECLARACION DE FUNCIONES void inorden(ARBOL); void preorden(ARBOL); void postorden(ARBOL); void treefree(ARBOL); /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/ /*-----------------------<FUNCION PRINCIPAL>--------------------------------*/ main(){ int i; //CONTADOR char newnod,chain[200],elementos; //DECLARACION DE CADENA,BANDERA Y VARIABLE QUE CONTIENE EL NUEVO VALOR A INSERTAR EN EL ARBOL clrscr(); ARBOL raiz=NULL; //DECLARACION DE VARIABLE DE TIPO ARBOL printf("\n\n\tIntroduzca una cadena de caracteres (max. 200 elementos):\n"); gets(chain); elementos=strlen(chain); //CHECA EL TAMAO DE LA CADENA Y ESTABLECE EL NUMERO DE NOD OS DEL ARBOL for(i=1;i<=elementos;i++) { newnod=chain[i-1]; insertanodonuevo(&raiz,newnod); } printf("\n\n preorden \t"); preorden(raiz); //LLAMADO A FUNCION DE RECORRIDO EN PREORDEN printf("\n\n inorden \t"); inorden(raiz); //LLAMADO A FUNCION DE RECORRIDO EN INORDEN printf("\n\n postorden \t"); postorden(raiz); //LLAMADO A FUNCION DE RECORRIDO EN POSTORDEN getch(); treefree(raiz); //LIBERACION DE MEMORIA DEL ARBOL. raiz=NULL; //ASIGNACION DE UN VALOR NULO A LA RAIZ. return 0; } /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/ /*CREA UN NUEVO NODO Y COLOCA LOS VALORES DEL NUEVO ELEMENTO EN LA POSICION CORRESPONDIENTE */ void insertanodonuevo(ARBOL *rarbol,int nuevo){ if(*rarbol==NULL){ //CREACION DE UN NUEVO NODO *rarbol=(NODO *)malloc(sizeof(NODO)); if(*rarbol!=NULL){ //ASIGNACION DE VALORES NUEVOS EN EL NODO NUEVO (*rarbol)->info=nuevo; (*rarbol)->izqnodo =NULL; (*rarbol)->dernodo=NULL;

} else{printf("\n Memoria No Disponible !!!!\n");} } else if(nuevo<(*rarbol)>info) //checa si el elemento nuevo es mayor que el elemento padre insertanodonuevo(&((*rarbol)>izqnodo),nuevo); //coloca el elemento a la izquierda del padre o raiz else if(nuevo>(*rarbol)>info) //checa si el elemento nuevo es menor que el elemento padre insertanodonuevo(&((*rarbol)>dernodo),nuevo); //coloca el elemento a la derecha del padre o raiz } /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/ //FUNCION ITERATIVA LA CUAL RECORRE EL ARBOL IMPRIMIENDO SIEMPRE EL VALOR //QUE CONTIENE LA RAIZ,DESPUES LA RAMA IZQUIERDA,LUEGO LA RAMA DERECHA,SIEMPRE //Y CUANDO LA RAIZ SEA DIFERENTE DE UN VALOR NULO, SI ES NULO SALTA A LA SIGUIENTE INSTRUCCI ON. void preorden(ARBOL rarbol){ if(rarbol!=NULL){ printf(" %c ",rarbol->info); preorden(rarbol->izqnodo); preorden(rarbol->dernodo); } } /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/ //FUNCION ITERATIVA LA CUAL RECORRE EL ARBOL BUSCANDO EL NODO MAS IZQUIERDO //QUE CONTIENE EL ARBOL O SEA HASTA QUE LA RAMA DEL ULTIMO NODO SEA NULO,LUEGO LA IMPRIME,DE SPUES //DESPUES LA RAIZ DEL SUB-ARBOL,Y LUEGO EL NODO DE LA DERECHA. void inorden(ARBOL rarbol){ if(rarbol!=NULL){ inorden(rarbol->izqnodo); printf(" %c ",rarbol->info); inorden(rarbol->dernodo); } } /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/ //FUNCION ITERATIVA LA CUAL RECORRE EL ARBOL BUSCANDO EL NODO QUE ESTA MAS A LA IZQUIERDA //LUEGO EL NODO DE LA DERECHA Y LUEGO LA RAIZ DE ESE SUB-ARBOL void postorden(ARBOL rarbol){ if(rarbol!=NULL){ postorden(rarbol->izqnodo); postorden(rarbol->dernodo); printf(" %c ",rarbol->info); } } /**-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/ //FUNCION ITERATIVA IDENTICA AL RECORRIDO EN POSTORDEN LA UNICA DIFERENCIA //ES QUE EN VEZ DE IMPRIMIR EN PANTALLA EL VALOR DE UN NODO ESTE ES //ELIMINADO DEL ARBOL LIBERANDO LA MEMORIA CON LA FUNCION free(), ELEGI ESTA //FORMA YA QUE SE ELIMINA PRIMERO LOS NODOS HIJO DE EL SUB-ARBOL Y LUEGO LA RAIZ //YA QUE SI SE ELIMINA LA RAIZ PRIMERO, LOS DATOS DE LOS HIJOS SE DESCONECTAN //DEL ARBOL PERO LA MEMORIA QUE OCUPABAN SIGUE SIENDO UTILIZADA Y DE ESTA FORMA //SE ELIMINA EL ARBOL DE ABAJO HACIA ARRIBA (O SEA DE LOS HIJOS A LA RAIZ). void treefree(ARBOL rarbol){ if(rarbol!=NULL){ treefree(rarbol->izqnodo); treefree(rarbol->dernodo); free(rarbol); } }

hola yo lo tengo pero dame tu msn y te lo mando ok! mejor lo kopio aki :P

#include <iostream.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <conio.h> #include <conio.c> struct Nodo { int Cod; char nombre[40]; Nodo *HI; Nodo *HD; };

Nodo* crearNodo(int id, char* n); Nodo* buscar (Nodo* p, int matricula); void insertar (Nodo** raiz, int matricula, char* nombre); void reemplazar(Nodo** act); void eliminar (Nodo** raiz, int matricula); void visualizar (Nodo* r); int profundidad (Nodo *raiz); Nodo* crearNodo(int id, char *n) { Nodo *t; t = (Nodo*)malloc(sizeof(Nodo)); t->Cod=id; strcpy(t->nombre, n); t->HI=NULL; t->HD=NULL; return(t); } //Busca un nodo dado: ITERATIVO Nodo* buscar (Nodo* raiz, int matricula) { int encontrado = 0; while (!encontrado && raiz != NULL) { if (matricula == raiz->Cod) encontrado = 1; else if (matricula < raiz->Cod)

raiz = raiz->HI; else if (matricula > raiz->Cod) raiz = raiz->HD; } return raiz; } /* //Busca un nodo dado: RECURSIVO Nodo* buscar (Nodo* raiz, int matricula) { if(raiz ==NULL || raiz->Cod==matricula) return(raiz); else if(matricula < raiz->Cod) buscar(raiz->HD, matricula); else buscar(raiz->HD, matricula); } */ //Inserta un nodo con matricula en el lugar que le corresponde void insertar (Nodo** raiz, int matricula, char *nombre) { if (!(*raiz)) *raiz = crearNodo(matricula, nombre); else if (matricula < (*raiz)->Cod) insertar (&((*raiz)->HI),matricula, nombre); else insertar (&((*raiz)->HD),matricula, nombre); } /** * * Elimina un nodo dado * Presenta dos casos: * 1. El NODO a eliminar es una HOJA o tiene un UNICO descendientelo que hay que * hacer es asignar el enlace del NODO PADRE el descendiente del nodo a eliminar * 2. El NODO tiene las dos subarboles NO VACIOS, para mantener la estructura * de un ABB, se tienen dos alternativas: * - Reemplazar el NODO por la menor de las claves mayores en su Subarbol derecho * - Reemplazar el NODO por la mayor de las claves menores en su Subarbol izquierdo * Se elige la SEGUNDA alternativa.Como las claves menores estan en la rama * iquierda, se elige la clave de mas a la derecha (hoja) que es el MAYOR de * los menores y que reemplaza el NODO a eliminar. La Funcion reemplazar() * realiza esa tarea. * */ void eliminar (Nodo** r, int matricula) { if (!(*r))

printf("!! Nodo no encontrado !!\n\n"); else if (matricula < (*r)->Cod) eliminar(&(*r)->HI, matricula); else if (matricula> (*r)->Cod) eliminar(&(*r)->HD,matricula); else // Nodo encontrado { Nodo* q; // puntero al nodo a suprimir q = (*r); if (q -> HI == NULL) (*r) = q -> HD; else if (q -> HD == NULL) (*r) = q -> HI; else { // tiene rama izquierda y derecha reemplazar(&q); } free(q); printf("%d eliminado ...!!\n\n", matricula); } } // void reemplazar(Nodo** act) { Nodo* a, *p; p = *act; a = (*act)->HI;// rama de menores while (a->HD) { p = a; a = a -> HD; } (*act)->Cod=a->Cod; strcpy((*act)->nombre,a->nombre); if (p == (*act)) p->HI = a -> HI; else p->HD = a -> HI; (*act) = a; } //Visualiza utilizando recorrido inorden void visualizar (Nodo* r) { if (r)

{ visualizar(r -> HI); printf("Matricula %d \t %s \n",r->Cod,r->nombre); visualizar(r -> HD); } } //Elimina cada uno de los nodos del arbol void eliminarbol(Nodo *r) { if (r != NULL) { eliminarbol(r -> HI); eliminarbol(r -> HD); printf("\tNodo borrado "); free(r); } } //Determina la mayor profundidad entre sub arbol izquierdo y derecho int profundidad (Nodo *raiz) { if (!raiz) return 0; else { int profundidadI = profundidad (raiz->HI); int profundidadD = profundidad (raiz->HD); if (profundidadI > profundidadD) return profundidadI + 1; else return profundidadD + 1; } }

int main() { int nm, i=1; char nom[30]; Nodo *Q, *raiz = NULL; do{ system("cls"); printf("\t\tARBOL BINARIO DE BUSQUEDA\n\n"); printf("\t1. Ingresar Registros\n"); printf("\t2. Mostrar el rbol\n"); printf("\t3. Buscar dato\n"); printf("\t4. Eliminar un registro\n"); printf("\t5. Altura del Arbol\n"); printf("\t6. Salir\n ");

do{ printf("\n\tDigite su opcion ---> "); scanf("%d%*c", &nm); }while(nm<1 || nm>6); { if (nm == 1) { // Crea el rbol do{ system("cls"); printf("\t\tRUTINA DE INGRESO DE DATOS \n\n"); printf("\tRegistro %d\n", i); printf("Codigo(0:Fin)---> "); scanf("%d%*c",&nm); if (nm) { printf("Nombre ---------> "); gets(nom); insertar(&raiz,nm,nom); } i=i+1; }while (nm); } if (nm == 2) { system("cls"); printf("\n\t RELACION DE ALUMNOS\n\n"); visualizar(raiz); system("pause"); } if (nm == 3) { int cl; system("cls"); printf("\n\t BUSCAR DATO\n\n"); printf("Codigo ---> "); scanf("%d",&cl); Q=buscar(raiz,cl); if(Q!=NULL) { printf("\nDato encontrato: %d %s\n\n",Q->Cod, Q->nombre); } else { printf("\n%d DATO NO encontrato...\n\n",cl); } system("pause"); } if (nm == 4)

{ int cl; system("cls"); printf("\n\t RUNTINA DE ELIMINACION\n\n"); printf("Codigo ---> "); scanf("%d",&cl); eliminar(&raiz,cl); system("pause"); } else if(nm == 5) { system("cls"); int Altura; printf("\n\t RUNTINA DE CALCULO DEL ARBOL\n\n"); Altura=profundidad(raiz); printf("\nAltura del arbol ---> %d\n", Altura-1); system("pause"); } } }while (nm != 6); system("PAUSE"); return (0); }

Ejercicio n5: Escribir una funcin que realice la reflexin de un rbol binario

OLUCIN AL EJERCICIO N 5 DE RBOLES BINARIOS

El cdigo es el siguiente:
void Refleja(ArbolB T) {

ArbolB Ti,Td; if(T!=ARBOLB_VACIO){ Ti=PodarHijoIzqdaB(RaizB(T),T); Td=PodarHijoDrchaB(RaizB(T),T); Refleja(Ti); InsertarHijoDrchaB(RaizB(T),Ti,T); Refleja(Td); InsertarHijoIzqdaB(RaizB(T),Td,T);

Ejercicio n6: Escribir una funcin recursiva que encuentre el nmero de nodos de un rbol binario

SOLUCIN AL EJERCICIO N 6 DE RBOLES BINARIOS

El algoritmo es muy sencillo considerando que el nmero de nodos de un rbol binario es el nmero de nodos del hijo a la izquierda ms el de su hijo a la derecha ms 1.El cdigo es el siguiente:
int numero(NodoB n,ArbolB T) { if (n==NODOB_NULO) return 0; else return 1+numero(HijoIzqdaB(n,T),T)+numero(HijoDrchaB(n,T),T); }

Para calcular el nmero de nodos de un rbol T se hara mediante la llamada numero(RaizB(T),T).

Ejercicio n7: Escribir una funcin recursiva que encuentre la altura de un rbol binario

SOLUCIN AL EJERCICIO N 7 DE RBOLES BINARIOS

La altura de un rbol T es uno ms el mximo de alturas de los subrboles izquierdo y derecho(La altura de un rbol nulo est indefinida).El cdigo es el siguiente:
#define MAXIMO(a,b) ((a) < (b)?(b):(a)) int altura(NodoN n,ArbolB T) { if(n==NODOB_NULO) return -1; else return 1+MAXIMO(altura(HijoIzqdaB(n,T),T),altura(HijoDrchaB(n,T),T));