Alberi binari - Tracing tramite il codice

Question

Alberi binari - Tracing tramite il codice

voti

0

Data l'albero binario mostrato sotto, determinare l'ordine in cui i nodi dell'albero binario illustrato di seguito sono visitati assuma la funzione A (root) viene richiamato. Si supponga che i nodi della struttura e puntatori sono definiti come indicato. Si supponga che la radice è un puntatore al nodo contenente 60. La mia risposta a questo problema è riportata qui sotto. È corretto? Che cosa ho fatto di sbagliato?

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

Risposta: In vuoto Una dice di stampa prima node_ptr-> dati in modo 60 viene stampato Allora la funzione chiama B (node_ptr-> sinistra) quindi entro B, A viene chiamato (node_ptr-> a sinistra), allora si stampano i dati che è 5 . E poi a (node_ptr-> destra) viene chiamato risalgono fino ad a, di stampa che i dati in modo da 8 ottiene stampati. Ora Im non così sicuro di cosa fare dopo, ma ottengo logicamente avrebbe senso per stampare 30, ma non sono sicuro di come il PTR ottiene dalle 8 alle 30. E poi se si continua nello stesso modello 38 viene stampato e 32 viene stampato. Per il sottoalbero destro ... 90 77 62 88

c algorithm data-structures binary-search-tree

È pubblicato 14/12/2010 alle 22:05
fonte dall'utente kachilous

In altre lingue...

4 risposte

voti

1

Per cominciare, il codice ha un sacco di errori in esso. Sto indovinando che dovrebbe essere più simile a questo:

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

Sei anche mescolando due diversi algoritmi di attraversamento. A()è pre-ordine, B()è in ordine. A()e B()dovrebbe essere che si fanno chiamare, non l'un l'altro. (Ancora un altro motivo per utilizzare variabile reale / nomi di funzione, invece di A, Be così via.)

Risposto il 14/12/2010 a 22:11
fonte dall'utente Dav3

voti

1

Basta scrivere lo stack completo di esecuzione nel corso del tempo. Come questo:

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

(Il resto dell'albero lasciato come esercizio al lettore.)

Poi basta andare da cima a fondo, scrivere i risultati delle istruzioni printf.

Risposto il 14/12/2010 a 22:14
fonte dall'utente jdmichal

voti

1

la traccia come sopra indicato non può essere corretto sia per pre-ordine o in ordine Pre - 60, 30, 5, 8 35 32 etc In - 5, 8, 30, 32, 35 etc.

Risposto il 28/03/2011 a 09:59
fonte dall'utente Brian

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

Aè un attraversamento pre-ordine, che Bè un attraversamento in ordine.

Un modo semplice per voi per capire l'ordine di stampa è quello di esaminare come si visita i nodi stessi. Io di solito disegnare un contorno intorno alla parte esterna della struttura (a partire dalla radice e si muove attraverso la sinistra oa destra in base alla sotto-albero che si sta traslazione prima). Se sto facendo un attraversamento di pre-ordine, stampare un nodo ogni volta che si muovono lungo la sua parte esterna . Se sto facendo un attraversamento in ordine, ho stampare un nodo solo quando mi muovo in esso (questo ha un senso quando si guarda attraversamenti in-ordine, perché si finisce per stampare le foglie prima, sono i primi nodi si sposta sotto quando si disegna il contorno). Se sto facendo un attraversamento post-ordine, stampare un nodo solo quando mi muovo lungo il suo interno .

AGGIORNARE

Il motivo 30 viene stampato dopo 5 e 8 è che non si sta eseguendo un attraversamento puramente pre-ordine. Stai saltando tra un pre-ordine e di un attraversamento in ordine.

Un modo semplice per capire l'ordine è quello di scrivere in realtà giù per le scale il codice passa attraverso, come si traccia attraverso di essa (io uso spesso penna / carta e penna per mantenere le informazioni insieme). Ad esempio, si potrebbe fare scrivere un call-stack in questo modo:

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)
        ...

Si può facilmente vedere l'ordine in cui vengono stampati i nodi, e ancora più importante, perché è "saltare" dalla stampa 8 alla stampa 30 (una chiamata ricorsiva è finito e si sta cadendo indietro di un livello).