Los árboles binarios - seguimiento mediante código

Question

Los árboles binarios - seguimiento mediante código

votos

0

Dado el árbol binario se muestra a continuación, determinar el orden en que se visitan los nodos del árbol binario se muestra a continuación suponiendo que la función A (raíz) se invoca. Suponga que los nodos del árbol y los punteros se definen como se muestra. Supongamos que la raíz es un puntero al nodo que contiene 60. Mi respuesta a este problema es la siguiente. ¿Es correcto? ¿Qué hice mal?

                                   60
                                 /    \
                                30     90
                               /  \   / 
                              5   38  77
                               \  /  / \
                               8 32 62  88



struct treeNode{
  int data;
  struct treeNode *left, *right:
  {

struct treeNode *tree_ptr;

void A(struct treeNode *node_ptr){
    if (node_ptr != NULL){
    printf(“%d ,”,node_ptr->data);
    B(node_ptr->left);
    B(node_ptr->right);
   }   
}

void B(struct treeNode *node_ptr){
    if (node_ptr != NULL) {
    A(node_ptr->left);
    printf(“%d ,”,node_ptr->data);
    A(node_ptr->right);
   }
 }

Respuesta: En un vacío que dice para la primera impresión node_ptr-> 60 datos de modo que se imprime A continuación, las llamadas de función B (node_ptr-> izquierda) y luego dentro de B, A se llama (node_ptr-> izquierda) y luego imprimir los datos que es 5 . Y entonces a (node_ptr-> derecha) obtiene la llamada volver a subir a a, por lo que los datos de impresión 8 se imprime. Ahora no estoy tan seguro de qué hacer a continuación, pero me sale lógicamente tendría sentido para imprimir 30 pero no estoy seguro de cómo el ptr recibe de 8 a 30. Y entonces si continúa con el mismo patrón se imprime 38 y 32 que se imprime. Para el subárbol derecho ... 90 77 62 88

c algorithm data-structures binary-search-tree

Publicado el 14/12/2010 a las 22:05
fuente por usuario kachilous

En otros idiomas...

4 respuestas

votos

1

Para empezar, el código tiene un montón de errores en ella. Supongo que debe ser de la misma familia:

struct treeNode{
  int data;
  struct treeNode *left, *right;
}

treeNode *tree_ptr;

void A(treeNode *node_ptr){
    if (node_ptr != NULL){  /// this could be just if(node_ptr)
        printf(“%d ,”,node_ptr->data);
        B(node_ptr->left);
        B(node_ptr->right);
    }   
}

void B(treeNode *node_ptr){
    if (node_ptr != NULL) {
        A(node_ptr->left);
        printf(“%d ,”,node_ptr->data);
        A(node_ptr->right);
    }
}

También está mezclando dos diferentes algoritmos de recorrido. A()es pre-orden, B()está en orden. A()y B()debe ser llamándose a sí mismos, no entre sí. (Sin embargo, otra razón para usar variable real / nombres de funciones en lugar de A, B, y tal.)

Respondida el 14/12/2010 a las 22:11
fuente por usuario Dav3

votos

1

Sólo tiene que escribir a cabo la pila de ejecución completa con el tiempo. Me gusta esto:

A(60)
  printf
  B(30)
    A(5)
      ...
    printf
    A(38)
      ...
  B(90)
    ...

(El resto del árbol deja como ejercicio para el lector.)

Entonces sólo tiene que ir de arriba a abajo, anotando los resultados de las sentencias printf.

Respondida el 14/12/2010 a las 22:14
fuente por usuario jdmichal

votos

1

la traza como se indicó anteriormente no puede ser correcta, ya sea para Pre-orden o en orden Pre - 60, 30, 5, 8 35 32 etc In - 5, 8, 30, 32, 35 etc.

Respondida el 28/03/2011 a las 09:59
fuente por usuario Brian

Vivin Paliath · Accepted Answer · 2010-12-14 22:15

Aes un recorrido pre-orden, mientras que Bes un recorrido en orden.

Una manera fácil para que usted pueda averiguar el orden de impresión es mirar la forma en que visita los propios nodos. Yo suelo dibujar un contorno alrededor de la parte exterior del árbol (a partir de la raíz y se mueve a través de la izquierda o hacia la derecha sobre la base de la sub-árbol que están atravesando primero). Si estoy haciendo un recorrido en preorden, imprimo un nodo cada vez que me muevo a lo largo de su exterior . Si estoy haciendo un recorrido en orden, imprimo un nodo sólo cuando muevo bajo ella (esto tiene sentido cuando se mira a recorridos en orden, porque se termina la impresión de las hojas primera, sino que son los primeros nodos que mueva bajo cuando se dibuja el contorno). Si estoy haciendo un recorrido posterior a la orden, imprimo un nodo sólo cuando muevo lo largo de su interior .

ACTUALIZAR

La razón 30 se imprime después de 5 y 8 es que no se está llevando a cabo un recorrido puramente pre-orden. Se salta entre una pre-orden y un recorrido en orden.

Una manera fácil de averiguar el orden es escribir realmente abajo los pasos que su código pasa por que se traza a través de él (Suelo utilizar la pluma / lápiz y papel para mantener la información en conjunto). Por ejemplo, se podría hacer escribir una pila de llamadas de esta manera:

A(60)
  printf(60)
  call B(60.left)
    B(30)
      call A(30.left)
        A(5)
          printf(5)
          call B(5.left)
            B(null)
          call B(5.right)
            B(8)
              call A(8.left)
                A(null)
              printf(8)
              call A(8.right)
                A(null)
      printf(30)
      call A(30.right)
        A(38)
        ...

Se puede ver fácilmente el orden en que se imprimen los nodos, y lo más importante, por la que "saltar" de impresión de 8 a imprimir 30 (una llamada recursiva ha terminado y que está retrocediendo un nivel).