Binärbaum-Traversierungen

Einen binären Suchbaum erzeugen und Preorder-, Inorder- oder Postorder-Traversierungen mit einer rekursiven C++-Funktion Schritt für Schritt durchgehen.

Alles wird in diesem Browser simuliert; nichts wird an einen Server gesendet.

Besucht den Knoten, dann den linken Teilbaum und danach den rechten.

Die Funktion wird mit Knoten 60 aufgerufen

Die Funktion wird mit Knoten 60 aufgerufen

Binärbaum

60458568215532

Ausgabe

Noch kein Knoten besucht

  • Nicht besucht
  • Läuft
  • Auf dem Stapel
  • Besucht

Schritt 1 / 44

Code

#include <iostream>
using namespace std;
class Node { // Ein Knoten enthält seinen Wert und Zeiger auf seine beiden Kinder
private: // Private Attribute: nur die Methoden greifen darauf zu
int value;
Node* left;
Node* right;
public:
Node(int v) : value(v), left(nullptr), right(nullptr) {}
int getValue() const { return value; }
Node* getLeft() const { return left; }
Node* getRight() const { return right; }
void setLeft(Node* n) { left = n; }
void setRight(Node* n) { right = n; }
};
void preorder(Node* node) { // Durchläuft den Teilbaum mit Wurzel node
if (node == nullptr) return; // Basisfall: ein leerer Teilbaum hat nichts zu besuchen
cout << node->getValue() << " "; // Besucht den Knoten: verarbeitet seinen Wert
preorder(node->getLeft()); // Durchläuft den linken Teilbaum
preorder(node->getRight()); // Durchläuft den rechten Teilbaum
} // Kehrt zum Aufrufer zurück
Node* insert(Node* root, int v) { // Fügt v in den Suchbaum ein und gibt die Wurzel zurück
if (root == nullptr) return new Node(v); // Freie Stelle: hier kommt der neue Knoten hin
if (v < root->getValue()) // Kleinere Werte gehen nach links, größere nach rechts
root->setLeft(insert(root->getLeft(), v));
else
root->setRight(insert(root->getRight(), v));
return root;
}
Node* buildTree() { // Baut den Baum auf, indem die Werte nacheinander eingefügt werden
int values[] = {60, 45, 85, 68, 21, 55, 32}; // Die Werte des angezeigten Baums in Einfügereihenfolge
Node* root = nullptr;
for (int v : values) root = insert(root, v);
return root;
}
int main() {
Node* root = buildTree(); // Der Baum aus der Animation, bereits aufgebaut
preorder(root); // Erster Aufruf, aus main
cout << endl; // Ende der Traversierung
return 0;
}

Dieses Tool erzeugt einen binären Suchbaum (BST) mit Zufallswerten und durchläuft ihn Schritt für Schritt mit einer rekursiven C++-Funktion. Sie wählen Preorder, Inorder oder Postorder und sehen am selben Baum, wann jeder Knoten besucht wird: vor seinen Kindern, zwischen ihnen oder nach ihnen. Knoten sind nach Zustand eingefärbt (nicht besucht, in Ausführung, auf dem Stack oder besucht), ein Ausgabestreifen zeigt die Werte in Besuchsreihenfolge, und der Code hebt die ausgeführte Zeile hervor. Auch Aufrufe mit nullptr werden gezeigt, der Basisfall, der die Rekursion stoppt. Die Größe lässt sich von 3 bis 15 Knoten ändern, und Sie können einen neuen Baum erzeugen. Alles wird in Ihrem Browser simuliert.

So funktioniert es

  1. Wählen Sie die Traversierung: Preorder, Inorder oder Postorder.
  2. Passen Sie die Baumgröße mit dem Schieberegler an oder drücken Sie Neuen Baum erzeugen. Die Animation springt zum ersten Schritt zurück.
  3. Drücken Sie Abspielen oder bewegen Sie sich mit den Schaltflächen für vorigen und nächsten Schritt und ändern Sie bei Bedarf die Geschwindigkeit.
  4. Beobachten Sie die farbigen Knoten, den Ausgabestreifen mit den besuchten Werten und die hervorgehobene Zeile des C++-Codes.

Häufig gestellte Fragen

Was ist ein Binärbaum und was ein binärer Suchbaum?
Ein Binärbaum ist eine Struktur, in der jeder Knoten höchstens zwei Kinder hat, links und rechts. In einem binären Suchbaum (BST) sind zudem die Werte im linken Teilbaum kleiner als der Knoten und die im rechten Teilbaum größer.
Was ist der Unterschied zwischen Preorder, Inorder und Postorder?
Es ändert sich, wann der Knoten relativ zu seinen Kindern besucht wird. Bei Preorder zuerst der Knoten, dann linker und rechter Teilbaum, bei Inorder linker Teilbaum, Knoten, rechter Teilbaum, bei Postorder linker, rechter Teilbaum und zuletzt der Knoten. Preorder dient zum Kopieren eines Baums, Inorder zum geordneten Lesen eines BST und Postorder zum Freigeben oder Auswerten eines Baums, weil Kinder vor ihrem Elternknoten verarbeitet werden.
Warum ist die Inorder-Traversierung eines BST sortiert?
Weil in einem BST alles links von einem Knoten kleiner und alles rechts größer ist. Der Besuch von linkem Teilbaum, Knoten und rechtem Teilbaum liefert die Werte vom kleinsten zum größten.
Wie implementiert man eine rekursive Traversierung in C++?
Mit einer Funktion, die einen Zeiger auf einen Knoten erhält. Ist der Zeiger nullptr, kehrt sie ohne Aktion zurück: Das ist der Basisfall. Sonst besucht sie den Knoten und ruft sich mit linkem und rechtem Kind auf, in der Reihenfolge, die die Traversierung verlangt.

Verwandte Tools