ARBOLES BINARIOS

1. El recorrido en preorden de un determinado árbol binario es: GEAIBMCLDFKJH y en inorden

IABEGLDCFMKHJ .

Resolver:

a) Dibujar el árbol binario.

b) Dar el recorrido en postorden.

c) Diseñar una función para dar el recorrido en postorden dado el recorrido en preorden e inorden
y escribir un programa para comprobar el resultado anterior.

2. Implementar una función no recursiva para recorrer un árbol binario en inorden.

3. Implementar una función no recursiva para recorrer un árbol binario en postorden.

4. Escribir una función recursiva que encuentre el número de nodos de un árbol binario.

5. Escribir una función recursiva que encuentre la altura de un árbol binario.

a)

b) El recorrido en postorden es IBAEDLFCHJKMG

c)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char *preorden="GEAIBMCLDFKJH";
char *inorden="IABEGLDCFMKHJ";
char *postorden;
/*---------------------------------------*/

void post(char *pre,char *in,char *pos,int n){

int longIzqda;

if(n!=0){
pos[n-1]=pre[0];
longIzqda=strchr(in,pre[0])-in;
post (pre+1,in,pos,longIzqda);
post (pre+1+longIzqda,in+1+longIzqda,pos+longIzqda,n-1-longIzqda);
}
}

/*----------------------------------------*/

int main(int argc,char *argv[]){

int aux;

aux=strlen(preorden);
postorden=(char *)malloc(aux*sizeof(char));
if (postorden){
printf("El preorden es: %s\n",preorden);
printf("El inorden es: %s\n",inorden);
post(preorden,inorden,postorden,aux);
postorden[aux]='\0';
printf("El postorden calculado es: %s\n",postorden);
free(postorden);
}
else{
fprintf(stderr,"Error: Sin memoria\n");
return 1;
}
return 0;
}
2)
5)

//La altura de un árbol T es uno más el máximo de alturas de los subárboles izquierdo y derecho(La
altura de un árbol nulo está indefinida).

#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));
}
4)

//El número de nodos de un árbol binario es el número de nodos del hijo a la izquierda más el de
su hijo a la derecha más
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 número de nodos de un árbol T se haría mediante la llamada
numero(RaizB(T),T).

*) recursivos

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

/* estructura autoreferenciada */
struct nodoArbol {
struct nodoArbol *ptrIzq; /* apuntador al subárbol izquierdo */
int dato; /* valor del nodo */
struct nodoArbol *prtDer; /* apuntador al subárbol derecho */
}; /* fin de la estructura nodoArbol */

typedef struct nodoArbol NodoArbol; /* sinónimo de la estructura nodoArbol */

typedef NodoArbol *ptrNodoArbol; /* sinónimo de NodoArbol* */

/* prototipos */
void insertaNodo( ptrNodoArbol *ptrArbol, int valor );
void inOrden( ptrNodoArbol ptrArbol );
void preOrden( ptrNodoArbol ptrArbol );
void postOrden( ptrNodoArbol ptrArbol );

/* la función main comienza la ejecución del programa */

int main(){
int i; /* contador para el ciclo de 1 a 10 */
 int elemento; /* variable para almacenar valores al azar */
ptrNodoArbol ptrRaiz = NULL; /* árbol inicialemnte vacío */

srand( time( NULL ) );

printf( "Los numeros colocados en el arbol son:\n" );

/* inserta valores al azar entre 1 y 15 en el árbol */

for ( i = 1; i <= 10; i++ ) {
elemento = rand() % 15;
printf( "%3d ", elemento );
insertaNodo( &ptrRaiz, elemento );
} /* fin de for */

/* recorre el árbol en preorden */

printf( "\nEl recorrido en preorden es:\n" );
preOrden( ptrRaiz );

/* recorre el árbol en in inorden */

printf( "\nEl recorrido inorden es:\n" );
inOrden( ptrRaiz );

/* recorre el árbol en postOrden */

printf( "\nEl recorrido en postOrden es:\n" );
postOrden( ptrRaiz );

return 0; /* indica terminación exitosa */

} /* fin de main */

/* inserta un nodo dentro del árbol */

void insertaNodo( ptrNodoArbol *ptrArbol, int valor ){
/* si el árbol esta vacío */
if ( *ptrArbol == NULL ) {
*ptrArbol = malloc( sizeof( NodoArbol ) );

/* si la memoria está asignada, entonces asigna el dato */

if ( *ptrArbol != NULL ) {
( *ptrArbol )->dato = valor;
( *ptrArbol )->ptrIzq = NULL;
( *ptrArbol )->prtDer = NULL;
} /* fin de if */
else {
 printf( "no se inserto %d. No hay memoria disponible.\n", valor );
} /* fin de else */

} /* fin de if */
else { /* el árbol no esta vacío */

/* el dato a insertar es menor que el dato en el nodo actual */

if ( valor < ( *ptrArbol )->dato ) {
insertaNodo( &( ( *ptrArbol )->ptrIzq ), valor );
} /* fin de if */

/* el dato a insertar es mayor que el dato en el nodo actual */

else if ( valor > ( *ptrArbol )->dato ) {
insertaNodo( &( ( *ptrArbol )->prtDer ), valor );
} /* fin de else if */
else { /* ignora el valor duplicado del dato */
printf( "dup" );
} /* fin de else */

} /* fin de else */

} /* fin de la función insertaNodo */

/* comienza el recorrido inorden del árbol */

void inOrden( ptrNodoArbol ptrArbol ){
/* si el árbol no esta vacío, entonces recórrelo */
if ( ptrArbol != NULL ) {
inOrden( ptrArbol->ptrIzq );
printf( "%3d", ptrArbol->dato );
inOrden( ptrArbol->prtDer );
} /* fin de if */

} /* fin de la función inOrden */

/* comienza el recorrido preorden del árbol */

void preOrden( ptrNodoArbol ptrArbol ){
/* si el árbol no esta vacío, entonces recórrelo */
if ( ptrArbol != NULL ) {
printf( "%3d", ptrArbol->dato );
preOrden( ptrArbol->ptrIzq );
preOrden( ptrArbol->prtDer );
} /* fin de if */
} /* fin de la función preOrden */

/* comienza el recorrido postOrden del árbol */

void postOrden( ptrNodoArbol ptrArbol ){
/* si el árbol no esta vacío, entonces recórrelo */
if ( ptrArbol != NULL ) {
postOrden( ptrArbol->ptrIzq );
postOrden( ptrArbol->prtDer );
printf( "%3d", ptrArbol->dato );
} /* fin de if */

} /* fin de la función postOrden */

/* Arbol Binario de Búsqueda en C */

#include <stdlib.h>
#include <stdio.h>

#define TRUE 1
#define FALSE 0

/* Estructuras y tipos */
typedef struct _nodo {
int dato;
struct _nodo *derecho;
struct _nodo *izquierdo;
} tipoNodo;

typedef tipoNodo *pNodo;

typedef tipoNodo *Arbol;

/* Funciones con árboles: */

/* Insertar en árbol ordenado: */
void Insertar(Arbol *a, int dat);
/* Borrar un elemento: */
void Borrar(Arbol *a, int dat);
/* Función de búsqueda: */
int Buscar(Arbol a, int dat);
/* Comprobar si el árbol está vacío: */
int Vacio(Arbol r);
/* Comprobar si es un nodo hoja: */
int EsHoja(pNodo r);
/* Contar número de nodos: */
int NumeroNodos(Arbol a, int* c);
/* Calcular la altura de un árbol: */
int AlturaArbol(Arbol a, int* altura);
/* Calcular altura de un dato: */
int Altura(Arbol a, int dat);
/* Aplicar una función a cada elemento del árbol: */
void InOrden(Arbol, void (*func)(int*));
void PreOrden(Arbol, void (*func)(int*));
void PostOrden(Arbol, void (*func)(int*));

/* Funciones auxiliares: */
void Podar(Arbol *a);
void auxContador(Arbol a, int*);
void auxAltura(Arbol a, int, int*);

void Mostrar(int *d);

/* Programa de ejemplo */
int main(){
Arbol ArbolInt=NULL;
int altura;
int nnodos;

/* Inserción de nodos en árbol: */

Insertar(&ArbolInt, 10);
Insertar(&ArbolInt, 5);
Insertar(&ArbolInt, 12);
Insertar(&ArbolInt, 4);
Insertar(&ArbolInt, 7);
Insertar(&ArbolInt, 3);
Insertar(&ArbolInt, 6);
Insertar(&ArbolInt, 9);
Insertar(&ArbolInt, 8);
Insertar(&ArbolInt, 11);
Insertar(&ArbolInt, 14);
Insertar(&ArbolInt, 13);
Insertar(&ArbolInt, 2);
Insertar(&ArbolInt, 1);
Insertar(&ArbolInt, 15);
Insertar(&ArbolInt, 10);
Insertar(&ArbolInt, 17);
Insertar(&ArbolInt, 18);
Insertar(&ArbolInt, 16);

printf("Altura de arbol %d\n", AlturaArbol(ArbolInt, &altura));

/* Mostrar el árbol en tres ordenes distintos: */

printf("InOrden: ");
InOrden(ArbolInt, Mostrar);
printf("\n");
printf("PreOrden: ");
PreOrden(ArbolInt, Mostrar);
printf("\n");
printf("PostOrden: ");
PostOrden(ArbolInt, Mostrar);
printf("\n");

/* Borraremos algunos elementos: */

printf("N nodos: %d\n", NumeroNodos(ArbolInt, &nnodos));
Borrar(&ArbolInt, 5);
printf("Borrar 5: ");
InOrden(ArbolInt, Mostrar);
printf("\n");
Borrar(&ArbolInt, 8);
printf("Borrar 8: ");
InOrden(ArbolInt, Mostrar);
printf("\n");
Borrar(&ArbolInt, 15);
printf("Borrar 15: ");
InOrden(ArbolInt, Mostrar);
printf("\n");
Borrar(&ArbolInt, 245);
printf("Borrar 245: ");
InOrden(ArbolInt, Mostrar);
printf("\n");
Borrar(&ArbolInt, 4);
printf("Borrar 4: ");
InOrden(ArbolInt, Mostrar);
printf("\n");
Borrar(&ArbolInt, 17);
printf("Borrar 17: ");
 InOrden(ArbolInt, Mostrar);
printf("\n");

/* Veamos algunos parámetros */

printf("N nodos: %d\n", NumeroNodos(ArbolInt, &nnodos));
printf("Altura de 1 %d\n", Altura(ArbolInt, 1));
printf("Altura de 10 %d\n", Altura(ArbolInt, 10));
printf("Altura de arbol %d\n", AlturaArbol(ArbolInt, &altura));

/* Liberar memoria asociada al árbol: */

Podar(&ArbolInt);
system("PAUSE");
return 0;
}

/* Poda: borrar todos los nodos a partir de uno, incluido */

void Podar(Arbol *a)
{
/* Algoritmo recursivo, recorrido en postorden */
if(*a) {
Podar(&(*a)->izquierdo); /* Podar izquierdo */
Podar(&(*a)->derecho); /* Podar derecho */
free(*a); /* Eliminar nodo */
*a = NULL;
}
}

/* Insertar un dato en el árbol ABB */

void Insertar(Arbol *a, int dat){
pNodo padre = NULL;
pNodo actual = *a;

/* Buscar el dato en el árbol, manteniendo un puntero al nodo padre */

while(!Vacio(actual) && dat != actual->dato) {
padre = actual;
if(dat < actual->dato) actual = actual->izquierdo;
else if(dat > actual->dato) actual = actual->derecho;
}

/* Si se ha encontrado el elemento, regresar sin insertar */

if(!Vacio(actual)) return;
/* Si padre es NULL, entonces el árbol estaba vacío, el nuevo nodo será
 el nodo raiz */
if(Vacio(padre)) {
*a = (Arbol)malloc(sizeof(tipoNodo));
(*a)->dato = dat;
(*a)->izquierdo = (*a)->derecho = NULL;
}
/* Si el dato es menor que el que contiene el nodo padre, lo insertamos
en la rama izquierda */
else if(dat < padre->dato) {
actual = (Arbol)malloc(sizeof(tipoNodo));
padre->izquierdo = actual;
actual->dato = dat;
actual->izquierdo = actual->derecho = NULL;
}
/* Si el dato es mayor que el que contiene el nodo padre, lo insertamos
en la rama derecha */
else if(dat > padre->dato) {
actual = (Arbol)malloc(sizeof(tipoNodo));
padre->derecho = actual;
actual->dato = dat;
actual->izquierdo = actual->derecho = NULL;
}
}

/* Eliminar un elemento de un árbol ABB */

void Borrar(Arbol *a, int dat){
pNodo padre = NULL;
pNodo actual;
pNodo nodo;
int aux;

actual = *a;
/* Mientras sea posible que el valor esté en el árbol */
while(!Vacio(actual)) {
if(dat == actual->dato) { /* Si el valor está en el nodo actual */
if(EsHoja(actual)) { /* Y si además es un nodo hoja: lo borramos */
if(padre) /* Si tiene padre (no es el nodo raiz) */
/* Anulamos el puntero que le hace referencia */
if(padre->derecho == actual) padre->derecho = NULL;
else if(padre->izquierdo == actual) padre->izquierdo = NULL;
free(actual); /* Borrar el nodo */
actual = NULL;
 return;
}
else { /* Si el valor está en el nodo actual, pero no es hoja */
padre = actual;
/* Buscar nodo más izquierdo de rama derecha */
if(actual->derecho) {
nodo = actual->derecho;
while(nodo->izquierdo) {
padre = nodo;
nodo = nodo->izquierdo;
}
}
/* O buscar nodo más derecho de rama izquierda */
else {
nodo = actual->izquierdo;
while(nodo->derecho) {
padre = nodo;
nodo = nodo->derecho;
}
}
/* Intercambiar valores de no a borrar u nodo encontrado
y continuar, cerrando el bucle. El nodo encontrado no tiene
por qué ser un nodo hoja, cerrando el bucle nos aseguramos
de que sólo se eliminan nodos hoja. */
aux = actual->dato;
actual->dato = nodo->dato;
nodo->dato = aux;
actual = nodo;
}
}
else { /* Todavía no hemos encontrado el valor, seguir buscándolo */
padre = actual;
if(dat > actual->dato) actual = actual->derecho;
else if(dat < actual->dato) actual = actual->izquierdo;
}
}
}

/* Recorrido de árbol en inorden, aplicamos la función func, que tiene

el prototipo:
void func(int*);
*/
void InOrden(Arbol a, void (*func)(int*)){
if(a->izquierdo) InOrden(a->izquierdo, func);
func(&(a->dato));
if(a->derecho) InOrden(a->derecho, func);
}

/* Recorrido de árbol en preorden, aplicamos la función func, que tiene

el prototipo:
void func(int*);
*/
void PreOrden(Arbol a, void (*func)(int*)){
func(&a->dato);
if(a->izquierdo) PreOrden(a->izquierdo, func);
if(a->derecho) PreOrden(a->derecho, func);
}

/* Recorrido de árbol en postorden, aplicamos la función func, que tiene

el prototipo:
void func(int*);
*/
void PostOrden(Arbol a, void (*func)(int*)){
if(a->izquierdo) PostOrden(a->izquierdo, func);
if(a->derecho) PostOrden(a->derecho, func);
func(&a->dato);
}

/* Buscar un valor en el árbol */

int Buscar(Arbol a, int dat){
pNodo actual = a;

/* Todavía puede aparecer, ya que quedan nodos por mirar */

while(!Vacio(actual)) {
if(dat == actual->dato) return TRUE; /* dato encontrado */
else if(dat < actual->dato) actual = actual->izquierdo; /* Seguir */
else if(dat > actual->dato) actual = actual->derecho;
}
return FALSE; /* No está en árbol */
}

/* Calcular la altura del nodo que contiene el dato dat */

int Altura(Arbol a, int dat){
int altura = 0;
 pNodo actual = a;

/* Todavía puede aparecer, ya que quedan nodos por mirar */

while(!Vacio(actual)) {
if(dat == actual->dato) return altura; /* encontrado: devolver altura */
else {
altura++; /* Incrementamos la altura, seguimos buscando */
if(dat < actual->dato) actual = actual->izquierdo;
else if(dat > actual->dato) actual = actual->derecho;
}
}
return -1; /* No está en árbol, devolver -1 */
}

/* Contar el número de nodos */

int NumeroNodos(Arbol a, int *contador){
*contador = 0;

auxContador(a, contador); /* Función auxiliar */

return *contador;
}

/* Función auxiliar para contar nodos. Función recursiva de recorrido en

preorden, el proceso es aumentar el contador */
void auxContador(Arbol nodo, int *c){
(*c)++; /* Otro nodo */
/* Continuar recorrido */
if(nodo->izquierdo) auxContador(nodo->izquierdo, c);
if(nodo->derecho) auxContador(nodo->derecho, c);
}

/* Calcular la altura del árbol, que es la altura del nodo de mayor altura. */
int AlturaArbol(Arbol a, int *altura){
*altura = 0;

auxAltura(a, 0, altura); /* Función auxiliar */

return *altura;
}

/* Función auxiliar para calcular altura. Función recursiva de recorrido en

postorden, el proceso es actualizar la altura sólo en nodos hojas de mayor
altura de la máxima actual */
void auxAltura(pNodo nodo, int a, int *altura){
/* Recorrido postorden */
if(nodo->izquierdo) auxAltura(nodo->izquierdo, a+1, altura);
if(nodo->derecho) auxAltura(nodo->derecho, a+1, altura);
/* Proceso, si es un nodo hoja, y su altura es mayor que la actual del
árbol, actualizamos la altura actual del árbol */
if(EsHoja(nodo) && a > *altura) *altura = a;
}

/* Comprobar si un árbol es vacío */

int Vacio(Arbol r){
return r==NULL;
}

/* Comprobar si un nodo es hoja */

int EsHoja(pNodo r){
return !r->derecho && !r->izquierdo;
}

/* Función de prueba para recorridos del árbol */

void Mostrar(int *d){
printf("%d, ", *d);
}

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <ctype.h>

struct arbol
{
int dato;
struct arbol *izq;
struct arbol *der;
}*raiz;

enum{ FALSO=0, VERDADERO };

/*PROTOTIPOS*/
void inicializar( void );
int vacio( struct arbol *hoja );
int eshoja( struct arbol *hoja );
struct arbol *insertar( struct arbol *raiz, struct arbol *hoja, int num );
int busqueda( struct arbol *hoja, int num );
int alturax( struct arbol *hoja, int num );
int alturafull( struct arbol *hoja, int *altura );
void auxaltura( struct arbol *hoja, int *altura, int cont );
int nodos( struct arbol *hoja );
void auxnodos( struct arbol *hoja, int *cont );
struct arbol *borrarx( struct arbol *hoja, int num );
struct arbol *podar( struct arbol *hoja );
void preorden( struct arbol *hoja );
void inorden( struct arbol *hoja );
void posorden( struct arbol *hoja );
void menu_recorridos( void );
void menu_busquedas( void );
void menu_alturas( void );
void menu_nodos( void );
void menu_podar( void );

void inicializar( void ){

raiz= NULL;
}

int vacio( struct arbol *hoja ){

if( !hoja ) return VERDADERO;
return FALSO;
}

int eshoja( struct arbol *hoja ){

if( hoja->izq==NULL && hoja->der==NULL )
return VERDADERO;
return FALSO;
}

struct arbol *insertar( struct arbol *raiz, struct arbol *hoja, int num ){
if( !hoja )
{
hoja= (struct arbol *) malloc( sizeof (struct arbol) );
hoja->dato= num;
 hoja->izq= NULL;
hoja->der= NULL;
if( !raiz ) return hoja;
else if( num<raiz->dato ) raiz->izq= hoja;
else raiz->der= hoja;
return hoja;
}
else if( num<hoja->dato )
insertar( hoja, hoja->izq, num );
else insertar( hoja, hoja->der, num );
return raiz;
}

int busqueda( struct arbol *hoja, int num ){

while( hoja )
{
if( num==hoja->dato ) return VERDADERO;
else
{
if( num<hoja->dato ) hoja= hoja->izq;
else hoja= hoja->der;
}
}
return FALSO;
}

int alturax( struct arbol *hoja, int num ){

int altura=1;

while( hoja )
{
if( num==hoja->dato ) return altura;
else
{
altura++;
if( num<hoja->dato ) hoja= hoja->izq;
else hoja= hoja->der;
}
}
return FALSO;
}
int alturafull( struct arbol *hoja, int *altura ){
auxaltura( hoja, altura, 1 );
return *altura;
}

void auxaltura( struct arbol *hoja, int *altura, int cont ){

if( !hoja ) return;

auxaltura( hoja->izq, altura, cont+1 );

auxaltura( hoja->der, altura, cont+1 );
if( (eshoja( hoja ) && cont)>*altura ) *altura= cont;
}

int nodos( struct arbol *hoja ){

int nodos=0;
auxnodos( hoja, &nodos );
return nodos;
}

void auxnodos( struct arbol *hoja, int *cont ){

if( !hoja ) return;

(*cont)++;
auxnodos( hoja->izq, cont );
auxnodos( hoja->der, cont );
}

struct arbol *borrarx( struct arbol *hoja, int num ){

if( hoja->dato==num )
{
struct arbol *p, *p2;

if( vacio( hoja ) )

{
free( hoja );
hoja= NULL;
return hoja;
}
else if( hoja->izq==NULL )
{
p= hoja->der;
free( hoja );
 return p;
}
else if( hoja->der==NULL )
{
p= hoja->izq;
free( hoja );
return p;
}
else
{
p= hoja->der;
p2= hoja->der;
while( p->izq ) p= p->izq;
p->izq= hoja->izq;
free( hoja );
return p2;
}
}
else if( num<hoja->dato )
hoja->izq= borrarx( hoja->izq, num );
else
hoja->der= borrarx( hoja->der, num );
return hoja;
}

struct arbol *podar( struct arbol *hoja ){

if( !hoja ) return hoja;

podar( hoja->izq );
podar( hoja->der );
free( hoja );
hoja= NULL;
return hoja;
}

/*Recorridos*/

void preorden( struct arbol *hoja ){

if( !hoja ) return;

printf( "%i ", hoja->dato );

preorden( hoja->izq );
 preorden( hoja->der );
}

void inorden( struct arbol *hoja ){

if( !hoja ) return;

inorden( hoja->izq );
printf( "%i ", hoja->dato );
inorden( hoja->der );
}

void posorden( struct arbol *hoja ){

if( !hoja ) return;

posorden( hoja->izq );
posorden( hoja->der );
printf( "%i ", hoja->dato );
}

/*Menus del Arbol*/

void menu_recorridos( void ){
char _op='S';

while( _op!='4' )
{
system ("cls");
//clrscr();
printf( "1. PreOrden." );
printf( "\n2. InOrden." );
printf( "\n3. PosOrden." );
printf( "\n4. Salir." );
printf( "\n\n:: " );
_op= getch();
switch( _op )
{
case '1':
preorden( raiz );
getch();
break;
case '2':
inorden( raiz );
getch();
 break;
case '3':
posorden( raiz );
getch();
break;
}
}
return;
}

void menu_busquedas( void ){

int val;

printf( "\n\nNumero: " );

scanf( "%i", &val );
if( busqueda( raiz, val ) )
printf( "\n\nEncontrado.." );
else printf( "\n\nError, No se encuentra." );
getch();
}

void menu_alturas( void ){

char _op='A';
int val, altura;

while( _op!='3' )
{
system ("cls");
//clrscr();
printf("1. Altura de Un Nodo" );
printf( "\n2. Altura de Todo el Arbol." );
printf( "\n3. Salir." );
printf( "\n\n:: " );
_op= getch();
switch( _op )
{
case '1':
printf( "\n\nNumero: " );
scanf( "%i", &val );
altura= alturax( raiz, val );
if( !altura ) printf( "\n\nImposible, numero inexistente." );
else printf( "\n\nLa Altura es: %i", altura );
 getch();
break;
case '2':
altura= 0;
printf( "\n\nLa Altura del Arbol es: %i", alturafull( raiz, &altura ) );
getch();
break;
}
}
return;
}

void menu_nodos( void ){

printf( "\n\nEl Numero de Nodos es: %i", nodos( raiz ) );
getch();
}

void menu_podar( void ){

char _op='A';
int val;

while( _op!='3' )
{
system ("cls");
//clrscr();
printf( "1. Podar Un Nodos del Arbol." );
printf( "\n2. Podar Todo el Arbol." );
printf( "\n3. Salir." );
_op= getch();
switch( _op )
{
case '1':
printf( "\n\nNumero: " );
scanf( "%i", &val );
raiz= borrarx( raiz, val );
printf( "\n\n.... Borrado ...." );
break;
case '2':
raiz= podar( raiz );
printf( "\n\nArbol Borrado por Completo." );
getch();
break;
 }
}
return;
}

int main(){
char _op='A';
int val;

inicializar();

while( _op!='S' )
{
system ("cls");
//clrscr();
printf( "Insertar." );
printf( "\nRecorridos." );
printf( "\nBusquedas." );
printf( "\nAlturas." );
printf( "\nNodos." );
printf( "\nPodar." );
printf( "\nSalir." );
printf( "\n\n:: " );
_op= toupper( getch() );
switch( _op )
{
case 'I':
printf( "\n\nNumero: " );
scanf( "%i", &val );
if( busqueda( raiz, val ) )
{
printf( "\n\nEste numero ya ha sido insertado." );
getch();
break;
}
raiz= insertar( raiz, raiz, val );
break;
case 'R':
if( vacio( raiz ) )
{
printf( "\n\nEl Arbol Aun esta Vacio." );
getch();
 break;
}
menu_recorridos();
break;
case 'B':
if( vacio( raiz ) )
{
printf( "\n\nEl Arbol Aun esta Vacio." );
getch();
break;
}
menu_busquedas();
break;
case 'A':
if( vacio( raiz ) )
{
printf( "\n\nEl Arbol Aun esta Vacio." );
getch();
break;
}
menu_alturas();
break;
case 'N':
if( vacio( raiz ) )
{
printf( "\n\nEl Arbol Aun esta Vacio." );
getch();
break;
}
menu_nodos();
break;
case 'P':
if( vacio( raiz ) )
{
printf( "\n\nEl Arbol Aun esta Vacio." );
getch();
break;
}
menu_podar();
break;
}
}
 printf( "\n\nPulsa para salir..." );
getchar();
return 0;
}