ich setze mich zurzeit mit diversen Algorithmen und Datenstrukturen auseinander (Stacks, Trees, Heaps, etc) und habe nun ein Problem eine gewisse Art der Rekursion zu verstehen. Es geht darum, dass man Binary Trees ja mit Traversierungsmethoden ausgeben kann (Preorder, Postorder, Inorder, Levelorder). Schlau ist, wenn man dafür eine Rekursion wie diese hier verwendet:

void preorderPrint( TreeNode *root ) {
           // Print all the items in the tree to which root points.
           // The item in the root is printed first, followed[*] by the
           // items in the left subtree and then the items in the
           // right subtree.
        if ( root != NULL ) {  // (Otherwise, there's nothing to print.)
           cout << root->item << " ";      // Print the root item.
           preorderPrint( root->left );    // Print items in left subtree.
           preorderPrint( root->right );   // Print items in right subtree.
        }
     } // end preorderPrint()

Angenommen, ich hab diesen Baum:
.......1
....../.\
.....2...3
..../.\...\
...4...5...6

dann wäre dies ja in Preorder so: 1 2 4 5 3 6

ich kann diesem Stückchen rekursiven Code da oben leider nur soweit folgen:

ich geh mit dem Wurzel-Knoten (1) rein, weil die if-Bedingung keine Probleme macht, kann ich auf Zeile 7 nun das cout ausführen. Zeile 8 ruft die Funktion rekursiv auf und übergibt den Knoten mit Wert 2 als neuen Wurzel-Knoten. If-Bedingung wieder okay -> cout und ich rufe die Funktion erneut auf. Dieses Mal übergebe ich den Knoten mit dem Wert 4 und mache wieder cout. So was macht das Programm danach? Weil es beim Knoten (4) ja kein left-Child mehr gibt, ist in die linke Richtung ja nichts mehr zu tun. Ich komm irgendwie einfach nicht dahinter, wie die Funktion jetzt 5, 3 und 6 findet. Wird denn die Zeile 8 [preorderPrint( root->left );] jetzt immer übersprungen?

ich hoffe, mir kann hier jemand ein wenig weiterhelfen.

Gruss

Also befindest du dich in der Funktion am Anfang. Der aktuelle Knoten (2) ist nicht NULL, also wird erneut der Wert ausgegeben. Jetzt wird erneut die Funktion mit dem linken Kindknoten aufgerufen (4).

Wieder in der Funktionn, Knoten (4) ist nicht NULL, Ausgabe, aufruf der Funktion mit dem linken Kindknoten (welcher NULL ist).

In der Funktion trifft die IF diesmal nicht zu, da der aktuelle Knoten NULL ist. Die Funktion macht also nichts.

Jetzt bist du in der Zeile 9, aber mit dem Knoten 4, den die Funktion war ja noch nicht zuende. Dort wird jetzt die selbe Funktion mit dem rechten Kindknoten ausgeführt, welcher wieder NULL ist, und die Funktion wieder nichts macht. Die Funktion mit dem Knoten 4 ist nun also fertig.

Jetzt befindest du dich wieder an der Stelle, wo du die Funktion mit dem linken Kindknoten von (2) aufgerufen hast, die Funktion war ja noch nicht fertig. Also rufst du die Funktion erneut auf und übergibst den rechten Kindknoten (5). Das selbe Spiel wie beim Knoten (4) beginnt.

Und so weiter und so weiter...

Jetzt kann ich der ganzen Sache schon wesentlich besser folgen. Ich frage mich aber noch, wieso die Funktion (nachdem Sie den Knoten (4) gänzlich bearbeitet hat) zum Knoten (2) geht. Merkt sich der Compiler "irgendwie", dass er dort noch nicht fertig ist?

Wenn eine Funktion aufgerufen wird, so geschieht folgender relevanter Punkt:
Die Addresse des Codestückes _nach_ dem Aufruf wird auf den Stack gespeichert. Dann wird zu der Addresse der Funktion gesprungen. Wenn die Funktion fertig ist, wird die gespeicherte Addresse vom Stack genommen und zu dieser wird zurückgesprungen.

Oder einfacher gesagt: Ja, der Compiler merkt sich, dass er dort noch nicht fertig ist.

vielen dank nochmals!