Crea un arbol binario y lo recorre en preorden, inorden, y en postOrden

1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <time.h>
4 
5 /* estructura autoreferenciada */struct nodoArbol {
6    struct nodoArbol *ptrIzq;  /* apuntador al subárbol izquierdo
7 */
8    int dato; /* valor del nodo */
9    struct nodoArbol *prtDer; /* apuntador al subárbol derecho */
10 }; /* fin de la estructura nodoArbol */ 
11 typedef struct nodoArbol NodoArbol; /* sinónimo de la estructura
12 nodoArbol */
13 typedef NodoArbol *ptrNodoArbol; /* sinónimo de NodoArbol* */
14  
15 /* prototipos */void insertaNodo( ptrNodoArbol *ptrArbol, int valor
16 );
17 void inOrden( ptrNodoArbol ptrArbol );
18 void preOrden( ptrNodoArbol ptrArbol );
19 void postOrden( ptrNodoArbol ptrArbol );
20  /* la función main comienza la ejecución del programa */
21 int main()
22 {
23    int i; /* contador para el ciclo de 1 a 10 */
24    int elemento; /* variable para almacenar valores al azar */ 
25 ptrNodoArbol ptrRaiz = NULL; /* árbol inicialemnte vacÃÂo */
26  
27    srand( time( NULL ) );
28    printf( "Los numeros colocados en el arbol son:n" );
29     /* inserta valores al azar entre 1 y 15 en el árbol */
30    for ( i = 1; i <= 10; i++ ) {
31       elemento = rand() % 15;
32       printf( "%3d", elemento );
33       insertaNodo( &ptrRaiz, elemento );   } /* fin de for */
34  
35    /* recorre el árbol en preorden */
36    printf( "nnEl recorrido en preorden es:n" );
37    preOrden( ptrRaiz ); 
38    /* recorre el árbol en in inorden */
39    printf( "nnEl recorrido inorden es:n" );
40    inOrden( ptrRaiz );
41     /* recorre el árbol en postOrden */
42    printf( "nnEl recorrido en postOrden es:n" );
43    postOrden( ptrRaiz );
44  
45    return 0; /* indica terminación exitosa */ 
46 } /* fin de main */
47  
48 /* inserta un nodo dentro del árbol */
49 void insertaNodo( ptrNodoArbol *ptrArbol, int valor ){
50    
51    /* si el árbol esta vacÃÂo */
52    if ( *ptrArbol == NULL ) {  
53       *ptrArbol = malloc( sizeof( NodoArbol ) ); 
 54       /* si la memoria está asignada, entonces asigna el dato */
55       if ( *ptrArbol != NULL ) {
56          ( *ptrArbol )->dato = valor;
57          ( *ptrArbol )->ptrIzq = NULL;         ( *ptrArbol )-
58 >prtDer = NULL;
59       } /* fin de if */
60       else {
61          printf( "no se inserto %d. No hay memoria disponible.n",
62 valor );
63       } /* fin de else */ 
64    } /* fin de if */
65    else { /* el árbol no esta vacÃÂo */
66  
67       /* el dato a insertar es menor que el dato en el nodo actual
68 */      if ( valor < ( *ptrArbol )->dato ) {
69          insertaNodo( &( ( *ptrArbol )->ptrIzq ), valor );
70       } /* fin de if */
71  
72       /* el dato a insertar es mayor que el dato en el nodo actual
73 */      else if ( valor > ( *ptrArbol )->dato ) {
74          insertaNodo( &( ( *ptrArbol )->prtDer ), valor );
75       } /* fin de else if */
76       else { /* ignora el valor duplicado del dato */
77          printf( "dup" );      } /* fin de else */
78  
79    } /* fin de else */
80  
81 } /* fin de la función insertaNodo */ 
82 /* comienza el recorrido inorden del árbol */
83 void inOrden( ptrNodoArbol ptrArbol )
84 {
85     /* si el árbol no esta vacÃÂo, entonces recórrelo */
86    if ( ptrArbol != NULL ) {
87       inOrden( ptrArbol->ptrIzq );
88       printf( "%3d", ptrArbol->dato );
89       inOrden( ptrArbol->prtDer );   } /* fin de if */
90  
91 } /* fin de la función inOrden */
92  
93 /* comienza el recorrido preorden del árbol */void
94 preOrden( ptrNodoArbol ptrArbol )
95 {
96  
97    /* si el árbol no esta vacÃÂo, entonces recórrelo */
98    if ( ptrArbol != NULL ) {       printf( "%3d", ptrArbol->dato );
99       preOrden( ptrArbol->ptrIzq );
100       preOrden( ptrArbol->prtDer );
101    } /* fin de if */
102  } /* fin de la función preOrden */
103  
104 /* comienza el recorrido postOrden del árbol */
105 void postOrden( ptrNodoArbol ptrArbol )
106 {  
107    /* si el árbol no esta vacÃÂo, entonces recórrelo */
108    if ( ptrArbol != NULL ) {
109       postOrden( ptrArbol->ptrIzq );
110       postOrden( ptrArbol->prtDer );      printf( "%3d", ptrArbol-
111 >dato );
112    } /* fin de if */
113  
114 } /* fin de la función postOrden */
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

4 comentarios en "Crea un arbol binario y lo recorre en preorden, inorden, y en

postOrden"

Shadow Darkness
0000-00-00 00:00:00
Corregido y ejecutado en Borland C++ 5.0

Saludos,
1 #include
2 #include
3 #include
4 #include
5  struct nodoArbol {
6    struct nodoArbol *ptrIzq;
7    int dato;
8    struct nodoArbol *prtDer;
9 }; 
10 typedef struct nodoArbol NodoArbol;
11 typedef NodoArbol *ptrNodoArbol;
12  
13 /* prototipos */void insertaNodo( ptrNodoArbol *ptrArbol, int valor
14 );
15 void inOrden( ptrNodoArbol ptrArbol );
16 void preOrden( ptrNodoArbol ptrArbol );
17 void postOrden( ptrNodoArbol ptrArbol );
18  int main(){
19    int i; /* contador para el ciclo de 1 a 10 */
20    int elemento; /* variable para almacenar valores al azar */
21    ptrNodoArbol ptrRaiz = NULL;
22     srand( time( NULL ) );
23    printf( "Los numeros colocados en el arbol son:n" );
24  
25    /* inserta valores al azar entre 1 y 15 en el arbol */
26    for ( i = 1; i dato = valor;         ( *ptrArbol )-&gt;ptrIzq =
27 NULL;
28          ( *ptrArbol )-&gt;prtDer = NULL;
29       } /* fin de if */
30
31
32
33
      else {
34
         printf( "no se inserto %d. No hay memoria disponible.n",
35
valor );      }
36
   }
37
   else { /* el arbol no esta vacio */
38
 
39
      /* el dato a insertar es menor que el dato en el nodo actual
40
*/      if ( valor dato ) {
41
         insertaNodo( &amp;( ( *ptrArbol )-&gt;ptrIzq ), valor );
42
      }
43
      /* el dato a insertar es mayor que el dato en el nodo actual
44
*/
45
      else if ( valor &gt; ( *ptrArbol )-&gt;dato ) {       
46
insertaNodo( &amp;( ( *ptrArbol )-&gt;prtDer ), valor );
47
      }
48
      else { /* ignora el valor duplicado del dato */
49
         printf( "# " );  // Imprime en valores duplicados
50
      }   }
51
} /* fin de la funcion insertaNodo */
52
 
53
/* comienza el recorrido inorden del arbol */
54
void inOrden( ptrNodoArbol ptrArbol ){   /* si el arbol no esta
55
vacio, entonces recorrelo */
56
   if ( ptrArbol != NULL ) {
57
      inOrden( ptrArbol-&gt;ptrIzq );
58
      printf( "%3d", ptrArbol-&gt;dato );
59
      inOrden( ptrArbol-&gt;prtDer );   }
60
} /* fin de la funcion inOrden */
61
 
62
/* comienza el recorrido preorden del arbol */
63
void preOrden( ptrNodoArbol ptrArbol ){   /* si el arbol no esta
64
vacio, entonces recorrelo */
65
   if ( ptrArbol != NULL ) {
66
      printf( "%3d", ptrArbol-&gt;dato );
67
      preOrden( ptrArbol-&gt;ptrIzq );
68
      preOrden( ptrArbol-&gt;prtDer );   }
69
} /* fin de la funcion preOrden */
70
 
71
/* comienza el recorrido postOrden del arbol */
72
void postOrden( ptrNodoArbol ptrArbol ){   /* si el arbol no esta
73
vacio, entonces recorrelo */
74
   if ( ptrArbol != NULL ) {
75
      postOrden( ptrArbol-&gt;ptrIzq );
76
      postOrden( ptrArbol-&gt;prtDer );
77
      printf( "%3d", ptrArbol-&gt;dato );   }
78
} /* fin de la funcion postOrden */
79
80
81
82

Hola, claro que te puedo ayudar. Los arboles binarios nacen de un nodo padre y puede tener 2 hijos, a su
vez un nodo hijo se puede convertir en padre y puede tener dos hijos, la idea es que no pueden ser mas
de 2 por eso lo de binario, un hijo no puede tener mas de un padre. Esto entonces son una lista con doble
enlaze la diferencia con las listas doblemente enlazadas es que un puntero va a a la derecha y el otro a la
izquierda (graficamente hablando ya que el computador no reconoce eso) no hay uno de vuelta. Ahora si
el arbol binario es ordenado el hijo la izquiera y toda la descendencia que va a la izquierda tiene que ser
menor que el padre y la descendencia de la derecha mayor.
ej:

10 <- padre
/\
7 15
/\/\
5 8 NULL 17
/\\
NULL NULL NULL

ese es un ejemplo grafico simple de un arbol binario ordenado.

Ahora ya empiezo con codigo c++.
/*definicion del nodo (estructura del arbol binario)*/
struct nodo{
int info;/*numero de cada elemento del arbol*/
struct nodo *izq ; /*apunta al hijo inquierdo*/
struct nodo *der; /*apunta al nodo derecho*/
}
typedef struct nodo *ptrnodo;

ptrnodo l,a,b,p; /*crea variables del tipo nodo, l sera el que tenga el primer numero*/
/*ahora comienza el manejo del programa, copia esto en un texto si esta desordenado*/

int main()
{
int temporal;
char op;
l=NULL;
do{
cout<<"ing numero: ";
cin>>temporal;
p=new nodo;
p->info=temporal;
p->der=NULL;
p->izq=NULL;
if (l==NULL)
{
l=p;
}
else
{
a=NULL;
a=l;
while(a!=NULL)
{
if(a->info>p->info)
{
if(a->izq!=NULL)
a=a->izq;
else
a->izq=p;
}
if(a->info<p->info)
{
if(a->der!=NULL)
a=a->der;
else
a->der=p;
}
}
}
cout<<"desea ing otro nº s/n: ";
cin>>op;
}while(op=='s');
/*Ya esta listo un ingreso de un arbol binario ordenado,ahora una busqueda*/
a=l;
cout<<"ING Nº A BUSCAR: ";
cin>>temporal;
while(a!=NULL)
{
if(temporal<a->info)
a=a->izq;
else if(temporal>a->der)
a=a->der;
else break;
}
if(a!=NULL)
cout<<"El numero fue encontrado";/*ESTA APUNTADO POR a*/
else cout<<"Numero no esta en el arbol";

/*ahora el eliminar te lo dejo a ti, aunque te dejo lo que es como una regla de eliminado.
cuando necesita eliminar un nodo que no tiene hijos solo eliminas y enlazas el ultimo a
NULL (para cerrar ese lado del arbol), si solo tiene un hijo solo enlazas el padre del a
eliminar si es que tiene con el hijo del a eliminar y luego simplemente borras, para eliminar
un arbol con mas de 1 hijo es mas complicado, en ese caso tienes que buscar el sucesor mas cercano
del a eliminar. Bueno espero que te sirva de ayuda, y si tienes una duda me preguntas. saludos

Enrique Quargnolo*/
return 0;
}
SOLUCIÓN AL EJERCICIO Nº 2 DE ÁRBOLES BINARIOS

Las soluciones son las siguientes:

A) El árbol correspondiente es el de la siguiente figura:

B)El recorrido en postorden es IBAEDLFCHJKMG.

C)El código solución al tercer apartado es el siguiente:

/*Fichero: comprobar.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;
}