Binary Trees - Tracing gjennom koden

Question

Binary Trees - Tracing gjennom koden

stemmer

0

Gitt det binære tre er vist nedenfor, bestemme i hvilken rekkefølge nodene i det binære tre er vist nedenfor blir besøkt under forutsetning av funksjonen A (rot) blir påkalt. Anta at de tre noder og pekere er definert som vist. Anta at rot er en peker til noden som inneholder 60. Mitt svar på dette problemet er gitt nedenfor. Er det riktig? Hva gjorde jeg galt?

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

Svar: I tomrommet A sier det til første utskrifts node_ptr-> data så 60 blir trykt Deretter kaller funksjonen B (node_ptr-> venstre) deretter innen B, A blir kalt (node_ptr-> venstre) deretter du skrive at data som er 5 . Og så A (node_ptr-> høyre) blir kalt gå tilbake til A, print som data så 8 blir skrevet ut. Nå Im ikke så sikker på hva jeg skal gjøre neste, men jeg får logisk at det ville være fornuftig å skrive ut 30, men jeg er ikke sikker på hvordan ptr får fra 8 til 30. Og så hvis du fortsetter i samme mønster 38 blir trykt og 32 blir skrevet ut. For den rette treet ... 90 77 62 88

c algorithm data-structures binary-search-tree

Publisert på 14/12/2010 klokken 21:05
kilden bruker kachilous

På andre språk...

4 svar

stemmer

1

For det første, har koden din en haug med feil i det. Jeg gjetter det bør være mer som dette:

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

Du er også blande to forskjellige traversering algoritmer. A()er pre-orden, B()er i-orden. A()og B()bør være å kalle seg selv, ikke hverandre. (Enda en grunn til å bruke ekte variabel / funksjonsnavn i stedet for A, Bog slikt.)

Svarte 14/12/2010 kl. 21:11
kilden bruker Dav3

stemmer

1

Bare skrive ut full gjennomføring stabelen over tid. Som dette:

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

(Resten av treet igjen som en øvelse for leseren.)

Så bare gå fra topp til bunn, skrive ned resultatene av printf uttalelser.

Svarte 14/12/2010 kl. 21:14
kilden bruker jdmichal

stemmer

1

trasen som er angitt ovenfor, kan ikke være korrekt for enten pre-orden eller i-rekkefølge Pre - 60, 30, 5, 8 35 32 etc I - 5, 8, 30, 32, 35 etc.

Svarte 28/03/2011 kl. 08:59
kilden bruker Brian

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

Aer en pre-ordre traversering, mens det Ber en i-rekkefølge traversering.

En enkel måte for deg å finne ut rekkefølgen på utskriften er å se på hvordan du besøker nodene selv. Jeg vanligvis trekke et omriss rundt utsiden av treet (starter ved roten og beveger seg gjennom den venstre eller høyre basert på sub-treet du er traversing først). Hvis jeg gjør en pre-order traversering, jeg skrive ut en node når jeg flytter sammen sin utenfor . Hvis jeg gjør en in-order traversering, jeg skrive ut en node bare når jeg flytter i henhold til det (dette er fornuftig når du ser på i-orden gjennomløping, fordi du ender opp med å skrive bladene først, de er de første noder du flytter etter når du tegner omrisset). Hvis jeg gjør en post-order traversering, jeg skrive ut en node bare når jeg flytter langs innsiden .

OPPDATER

Årsaken 30 blir skrevet ut etter 5 og 8 er at du ikke utfører en ren pre-order traversering. Du hopper mellom en pre-order og en in-order traversering.

En enkel måte å finne ut ordren er å faktisk skrive ned trappen koden din går gjennom som du spore gjennom det (jeg bruker ofte penn / blyant og papir for å holde informasjonen sammen). For eksempel kan du gjøre skrive ut en samtale-stack som dette:

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

Du kan enkelt se i hvilken rekkefølge nodene er skrevet ut, og enda viktigere, hvorfor du "hoppe" fra utskrift 8 til utskrift 30 (en rekursiv samtalen er avsluttet og du faller tilbake ett nivå).