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

¿Has encontrado un error? ¿Tienes la solución? Deja tu correción ;-)

Antes de comentar: Gran parte de los ejercicios propuestos no tienen librerías debido a que Wordpress las eliminó al verlas como etiquetas HTML. Si sabes/tienes/conoces las librerías que hacen falta, déjalo en los comentarios. Y lo mas importante: Todos los ejemplos fueron realizados por estudiante con únicamente conocimiento básico del lenguaje, no de programación.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
#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( "nnEl recorrido en preorden es:n" );
   preOrden( ptrRaiz ); 
   /* recorre el árbol en in inorden */
   printf( "nnEl recorrido inorden es:n" );
   inOrden( ptrRaiz );
    /* recorre el árbol en postOrden */
   printf( "nnEl 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 */

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

Shadow Darkness

Corregido y ejecutado en Borland C++ 5.0

Saludos,

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

Victor De la Rocha

Muchas gracias por el aporte :)

Punto importante: Si vas a sugerir un segmento de código en algún lenguaje debes hacerlo así:

  • Si es lenguaje C <code lang="c">Código en C</code>
  • Si es lenguaje Pascal <code lang="pascal">Aquí dentro el código de Pascal</code>.

De esta manera el código coloreas el código.

Deja un comentario

Suscribirse a los comentarios.