Binary Trees - Tracing door middel van code

Question

Binary Trees - Tracing door middel van code

stemmen

0

Aangezien de binaire boom hieronder weergegeven, bepalen de volgorde waarin de knooppunten van de binaire boom onderstaande bezocht veronderstelling dat de functie A (root) aangeroepen. Neem aan dat de boom knooppunten en pointers worden gedefinieerd als getoond. Neem aan dat wortel is een pointer naar het knooppunt met 60. Mijn antwoord op dit probleem wordt hieronder gegeven. Klopt het? Wat heb ik verkeerd gedaan?

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

Antwoord: In leegte A zegt tot eerste afdruk node_ptr-> gegevens, zodat 60 wordt afgedrukt Dan roept de functie B (node_ptr-> links) vervolgens binnen B, A wordt aangeroepen (node_ptr-> links) dan print u die gegevens dat is 5 . En dan A (node_ptr-> rechts) wordt aangeroepen gaan terug naar A, af te drukken dat de gegevens zo 8 wordt afgedrukt. Nu Im niet zo zeker wat te doen, maar ik krijg logisch zou het zinvol zijn om af te drukken 30 maar ik ben niet zeker hoe de ptr krijgt van 8 tot 30. En als je verder in het zelfde patroon 38 wordt gedrukt en 32 wordt afgedrukt. Voor de rechter deelboom ... 90 77 62 88

c algorithm data-structures binary-search-tree

De vraag is gesteld op 14/12/2010 om 22:05
bron van user kachilous

In andere talen...

4 antwoorden

stemmen

1

Om te beginnen, de code heeft een heleboel fouten in het. Ik gok dat het moet meer zijn als dit:

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

Je bent ook het mengen van twee verschillende traversal algoritmen. A()is pre-orde, B()in orde. A()en B()zou moeten zijn die zichzelf, elkaar niet. (Nog een andere reden om reële variabele / functienamen gebruiken in plaats van A, Ben dergelijke.)

antwoordde op 14/12/2010 om 22:11
bron van user Dav3

stemmen

1

Schrijf gewoon de volledige uitvoering stack na verloop van tijd. Soortgelijk:

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

(De rest van de structuur als opgave voor de lezer.)

Dan ga je gewoon van boven naar beneden, het opschrijven van de resultaten van de printf verklaringen.

antwoordde op 14/12/2010 om 22:14
bron van user jdmichal

stemmen

1

het spoor zoals hierboven aangegeven kunnen niet juist voor ofwel pre-order of in orde Pre - 60, 30, 5, 8, 35 etc. 32 In - 5, 8, 30, 32, 35 etc.

antwoordde op 28/03/2011 om 09:59
bron van user Brian

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

Ais vooraf bestellen traversal, dat Bis in orde traversal.

Een gemakkelijke manier voor u om te achterhalen van de volgorde van afdrukken is om te kijken naar hoe je een bezoek aan de knooppunten zelf. Ik meestal trek een omtrek rond de buitenkant van de boom (beginnend bij de wortel en bewegen door links of rechts op basis van de sub-boom u eerst doorkruisen). Als ik ben bezig met een pre-order traversal, print ik een knoop wanneer ik bewegen langs de buitenzijde . Als ik ben bezig met een in-orde traversal, print ik een knooppunt alleen als ik verhuis in het kader van deze (dit zinvol is als je kijkt naar in-order traversals, omdat je uiteindelijk het afdrukken van de bladeren eerste, ze zijn de eerste nodes je beweegt onder wanneer je de omtrek te tekenen). Als ik ben bezig met een post-order traversal, print ik een knooppunt alleen als ik langs haar binnen .

BIJWERKEN

De reden 30 wordt uitgeprint na 5 en 8 is dat je niet uitvoeren van een puur pre-order traversal. Je springt tussen een pre-order en een in-orde traversal.

Een gemakkelijke manier om erachter te komen de opdracht is om daadwerkelijk noteer de stappen uw code gaat door als u traceren doorheen (ik gebruik vaak pen / potlood en papier om de informatie bij elkaar te houden). Bijvoorbeeld, zou u kunnen doen uitschrijven van een call-stack als volgt uit:

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

U kunt eenvoudig zien de volgorde waarin de knooppunten worden afgedrukt, en nog belangrijker, waarom je "springen" van het afdrukken van 8 tot en met het afdrukken van 30 (een recursieve aanroep is afgelopen en u bent terug te vallen een niveau).