if ( node==NULL )

return;

else
{
node->display();
display(node->getLeft());
display(node->getRight());
}
}

Wie ihr seht sollen alle Knoten eines Binärbaums ausgegeben werden. Es wird zuerst der linke Zweig ausgegeben. Dabei wird mittels Rekursion immer wieder der linke Knoten aufgerufen bis dieser Null ist . Dann wird abgebrochen.
Ich versteh grad nicht wann der rechte Zweig also display(node->getRight());
aufgerufen wird. Ich kapier wohl die Rekursion grade nicht.

Helft mir mal . Danke !

1. Code Tags wären super:

void BinaryTree::display(Data* node)
{//rekursive Loesung

   if ( node==NULL ) return;

   else
   {
      node->display();
      display(node->getLeft());
      display(node->getRight());
   }
}

2. So wie du deine display Methode defniert hast, dürfte die obige Lösung sich nichtmal kompilieren lassen.

3. Der richtige Weg wäre bei JEDEM Methodenaufruf die Display Methode des linken UND des rechten Nodes aufzurufen.

struct node
          {
               int data;
               node *left;
               node *right;
          };

void inorder(node *tree)
          {
               if(tree!=NULL)
               {
                    inorder(tree->left);
                    cout<<tree->data;
                    inorder(tree->right);
                    getch();
               }
          }

Ich gehe mal davon aus das es um diese drei Zeilen geht, der Rest dürfte klar sein oder?

inorder(tree->left);
cout<<tree->data;
inorder(tree->right);

Der Durchlauf des rechten Zweigs wird begonnen sobald es auf auf der linken Seite keine Elemente mehr gibt. Also im Normalfall am unteren Ende des Baumes.
Mal dir doch mal auf einen Zellulosedatenträger einen Binary Tree auf und versuch das nachzuverfolgen. Leg dir einfach im Programm einen Tree mit ein paar Verzweigungen an und probier ein bisschen herum.

#edit: Zugegebenermaßen, diese Rekursion ist nicht unbedingt die einfachste. Bist du dir sicher das du eine "normale" Rekursion verstanden hast? Also z.B. sowas:

class Node
{
    public:
    Node *next;
    int data;
};

Node *node;

void displayList()
{
    std::cout << node->data << std::endl;
    if(node->next != NULL)
    {
        displayList();
    }
}

inorder(tree->left); 
cout<<tree->data;             //Warum hier Ausgabe der Daten,
inorder(tree->right);
                             // aber beim Durchlauf des rechten Zweigs nicht ???

Der Punkt ist, du rufst für den rechten Zweig ebenfalls inorder() auf.

inorder(tree->right);

Entsprechend werden auch für diesen die Daten ausgegeben.

Jeder Knoten hat ja wiederum zwei Verzweigungen, eine links und eine rechts.

Node
          |
   --------------
   |            |
 Links        Rechts

Zuerst wird praktisch der letzte Knoten der am weitesten Links ist ausgegeben, danach kommt der rechte "daneben". Der Baum wird praktisch von unten nach oben ausgegeben.

Wieso steht denn der tree->left Zeiger gleich ganz unten ?
wenn ich den root node übergebe würde er doch ganz oben stehn.

Steig noch nicht ganz dahinter.

Danke

cout wird ja zum ersten mal erst dann aufgerufen wenn du ganz am Ende bist. Mal angenommen wir sind am dem Punkt wo das if(tree != NULL) zuschlägt.

void inorder(node *tree)
          {
               if(tree!=NULL)
               {
                    inorder(tree->left);
                    cout<<tree->data; // <= hier
                    inorder(tree->right);
                    getch();
               }
          }

Dann bist du ja praktisch "ganz links unten" im Baum und die Funktion kommt zum ersten mal zurück, also bist du dort wo ich es Code markiert habe. Dann werden die Daten also zum ersten mal ausgegeben und er prüft ob auf der rechten Seite evtl. noch etwas ist. Wenn nein kommt auch diese Funktion zurück und du kommst an den zweiten Node von links unten gesehen und hast wieder genau die gleiche Prozedur: er gibt die Daten des Nodes aus und prüft dann ob nicht rechts noch etwas da ist. Sinnvoller wäre die Funktion wohl so:

void inorder(node *tree)
          {
               if(tree!=NULL)
               {
                    cout<<tree->data;
                    inorder(tree->left);
                    inorder(tree->right);
                    getch();
               }
          }

Dann würde der Baum von oben nach unten ausgegeben (zugegebenermaßen, erst die linke Seite :S).

Danke

Die if Sequenz prüft ob tree!= NULL;

ist der rechte Knoten NULL dann geht er doch gar nicht mehr in den Block rein.
Das ist mein Problem.

Danke

Am besten schnappst du dir mal ein Bleistift und ein Block und skizzierst dir den Callstack nach, dann sollte es dir klar werden. Oder dann fehlt dir irgendwelches Grundwissen über Funktionen

Grüssli

void rekur(int x)
{

if(x>0)              //Hier bricht doch auch die Rekursion ab, wieso aber nicht 
{                    // bei tree!= NULL
cout<<x<<" "; x--;
rekur(x);
}

}

Ich skizziere mal das Nodebeispiel:

call inorder("value")                           ---> erster Aufruf

if "value" valid? -> yes
call inorder("left of value")                   ---> zweiter Aufruf
  if "left of value" valid? -> yes
  call inorder("left of left of value")         ---> dritter Aufruf
    if "left of left of value" valid? -> no
    return                                      ---> dritter Aufruf beendet
                                                     zurück zum Zweiten
  call inorder("right of left of value")        ---> vierter Aufruf
    if "right of left o value" valid? -> no
    return                                      ---> vierter Aufruf beendet
                                                     zurück zum Zweiten
  return                                        ---> zweiter Aufruf beendet
                                                     zurück zum Ersten
call inorder("right of value")                  ---> fünfter Aufruf
  if "right of value" valid? -> yes
  call inorder("left of right of value")        ---> sechster Aufruf
    if "left of right of value" valid? -> no
    return                                      ---> sechster Aufruf beendet
                                                     zurück zum Fünften
  call inorder("right of right of value")       ---> siebter Aufruf
    if "right of right of value" valid? -> no
    return                                      ---> siebter Aufruf beendet
                                                     zurück zum Fünften
  return                                        ---> fünfter Aufruf beendet
                                                     zurück zum Ersten
return                                          ---> erster Aufruf beendet

- Rekursions Ende -

Also damit sollte es nun echt klar werden. Ansonsten muss ich wohl aufgeben ...

Grüssli

Wie komme ich also zu dem parent Knoten zurück.

void foo()
{
}

// Ist das gleiche wie:

void foo()
{
  return;
}

Wenn die Funktion am Ende ankommt oder zu einem return gelangt, wird sie beendet und kehrt in die Aufruferfunktion zurück. Die Aufruferfunktion macht dann dort weiter, wo sie die Funktion aufgerufen hat.

Also kurz an zwei unterschiedlichen Funktionen erläutert:

void bar()
{
  // bar wird ausgeführt.
}

void foo()
{
  // Der Prozess/Thread kommt in dies Funktion foo.

  bar(); // bar wird aufgerufen.
  // bar wurde ausgeführt.

  bar(); // bar wird aufgerufen.
  // bar wurde ausgeführt.
}

Lass es dir an einer einfachen Rekursion von einem Programm zeigen

#include <iostream>

int recTest(int x)
{
  std::cout << "Funktion Nr. " << x << " startet." << std::endl;

  if(x < 5)
  {
    recTest(x + 1);

    std::cout << "Zurueck in Funktion Nr. " << x << std::endl;
  }
  else
  {
    std::cout << "x >= 5" << std::endl;
  }

  std::cout << "Funktion Nr. " << x << " endet." << std::endl;
}

int main()
{
  recTest(0);

  return 0;
}

Grüssli

Vielen herzlichen Dank !