Ein bin?rer Suchbaum (BST) ist ein bin?rer Baum, bei dem das linke Subtree nur Knoten mit weniger als der Wert des Knotens enth?lt, der rechte Subtree nur Knoten mit Werten enth?lt, die gr??er sind als der Wert des Knotens, und beide Teilbeutel müssen auch BSTs sein; 1. Die C -Implementierung umfasst eine Treenode -Struktur mit Wert, links und rechten Zeigern. 2. Die BST -Klasse bietet mit rekursiven Helfer -Methoden Einfügen, Suche und unbestreitende Traversaloperationen. 3. Insertion beh?lt die BST -Eigenschaft durch Vergleich von Werten und Vermeidung von Duplikaten bei. V. 5. In-Ordnung-Traversal-Druckwerte in sortierter Reihenfolge durch Besuch nach links, Wurzel, dann rechts; 6. Zu den wichtigsten überlegungen zur Produktion geh?rt das Hinzufügen eines Destruktors zur Speicherung des Ged?chtnisses, das Ausgleich des Baumes mit AVL oder rot-schwarzer Logik sowie die Implementierung iterativer Methoden, um den Stapelüberlauf zu verhindern, wodurch dieses Beispiel zu einem grundlegenden Verst?ndnis von BSTs in c.

Hier ist ein praktisches C-Beispiel für einen bin?ren Suchbaum (BST) mit grundlegenden Operationen: Einfügen, Suche und In-Ordnung-Traversal.

? Was ist ein bin?rer Suchbaum?

Ein BST ist ein bin?rer Baum, bei dem:

• Der linke Teilbaum eines Knotens enth?lt nur Knoten mit niedrigeren Werten als der Wert des Knotens.
• Der rechte Subtree enth?lt nur Knoten mit Werten, die gr??er sind als der Wert des Knotens.
• Sowohl linke als auch rechte Unterb?ume müssen auch bin?re Suchb?ume sein.

? C Implementierungsbeispiel

 #include <iostream>
Verwenden von Namespace STD;

// Definieren Sie die Struktur eines Baumknotens
Struktur Treenode {
    int Wert;
    Treenode* links;
    Treenode* rechts;

    // Konstruktor
    Treenode (int Val): Wert (val), links (nullptr), rechts (nullptr) {}
};

// Bin?re Suchbaumklasse
Klasse BST {
?ffentlich:
    Treenode* Wurzel;

    // Konstruktor
    Bst (): root (nullptr) {}

    // ?ffentliche Einfügungsfunktion
    void Insert (int value) {
        root = Insertrecursive (root, value);
    }

    // ?ffentliche Suchfunktion
    bool such (int value) {
        return searchRecursive (root, value);
    }

    // In-Order-Traversal (druckt Werte in sortierter Reihenfolge)
    void inOrder () {
        in OrderRecursive (Wurzel);
        cout << endl;
    }

Privat:
    // Helfer: Knoten rekursiv einfügen
    Treenode* Insertrecursive (Treenode* Knoten, int Wert) {
        // Wenn der Baum leer ist, erstellen Sie einen neuen Knoten
        if (node == nullptr) {
            Neue Treenode (Wert) zurückgeben;
        }

        // ansonsten den Baum hinunterziehen
        if (value <node-> value) {
            Node-> links = Insertrecursive (Knoten-> links, Wert);
        } else if (value> node-> value) {
            node-> right = insertrecursive (Knoten-> rechts, Wert);
        }
        // Duplikate ignorieren (value == node-> value)

        Return Node;
    }

    // Helfer: Rekursiv suchen
    bool SearchRecursive (Treenode* Knoten, int Wert) {
        if (node == nullptr) {
            false zurückgeben; // nicht gefunden
        }
        if (node-> value == value) {
            zurückkehren; // Gefunden
        }
        if (value <node-> value) {
            return SearchRecursive (Knoten-> links, Wert);
        } anders {
            return SearchRecursive (Knoten-> rechts, Wert);
        }
    }

    // Helfer: In -Ordnung -Traversal (links -> Wurzel -> rechts)
    void in OrderRecursive (Treenode* Knoten) {
        if (node! = nullptr) {
            in OrderRecursive (Knoten-> links);
            cout << node-> value << "";
            in OrderRecursive (Knoten-> rechts);
        }
    }
};

// Beispielnutzung
int main () {
    BST -Baum;

    // Werte einfügen
    Baum.insert (50);
    Baum.insert (30);
    Baum.insert (70);
    Baum.insert (20);
    Baum.insert (40);
    Baum.insert (60);
    Baum.insert (80);

    // Drucken in Ordnung durchqueren (sollte sortiert werden)
    cout << "In-Ordnung Traversal:";
    Tree.inorder (); // Ausgabe: 20 30 40 50 60 70 80

    // nach Werten suchen
    cout << "Suche 40:" << (Tree.Search (40)? "Found": "Nicht gefunden") << endl;
    cout << "Suche 25:" << (Tree.Search (25)? "Found": "Nicht gefunden") << endl;

    Rückkehr 0;
}

? Ausgabe:

 In-Ordnung-Traversal: 20 30 40 50 60 70 80
Suche 40: gefunden
Suche 25: Nicht gefunden

? Schlüsselpunkte:

• Insertion beh?lt die BST -Eigenschaft durch Vergleich von Werten bei.
• Die Suche ist effizient (O (log n) im Durchschnitt), indem sie nach links/rechts gehen.
• In-Ordnung-Traversal gibt sortierter Ausgang-einen der wichtigsten Vorteile von BSTs.
• Diese Version ignoriert doppelte Werte . Sie k?nnen es ?ndern, um Duplikate zuzulassen (z. B. durch Verwendung von oder das Speichern von Anzahl).

?? Hinweis:

Dies ist eine grundlegende Implementierung. Betrachten Sie für die Produktionsnutzung:

• Speicherreinigung (fügen Sie einen Destruktor hinzu, um Knoten zu l?schen).
• Balancieren (verwenden Sie AVL- oder Rotschwarzb?ume, um verzerrte B?ume zu vermeiden).
• Iterative Versionen, um einen Stapelüberlauf in tiefen B?umen zu vermeiden.

Grunds?tzlich bietet Ihnen dieses Beispiel eine solide Grundlage, um zu verstehen, wie BSTs in c funktionieren.

Das obige ist der detaillierte Inhalt vonC Bin?r -Suchbaumbeispiel. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!