Vorwort:
Ist es sinnlos, gewöhnliche Binärbäume hinzuzufügen, zu löschen, zu überprüfen und zu ändern? Warum sollten wir also zuerst gewöhnliche Binärbäume lernen?
Nennen Sie die folgenden zwei Gründe:
1. Legen Sie den Grundstein für das spätere Erlernen komplexerer Binärbäume. (Suchbinärbaum, ALV-Baum, Rot-Schwarz-Baum, B-Baum-Serie – ausgeglichener Suchbaum mit mehreren Gabeln)
2. Es gibt viele OJ-Algorithmusprobleme von Binärbäumen, die auf gewöhnlichen Binärbäumen basieren
Beginnen wir die Reise des mit Datenstrukturen verketteten Binärbaums! ! !
1. Durchquerung des verketteten Binärbaums
1.1 Pre-Order-, In-Order- und Post-Order-Traversal-Konzepte
Gemäß den Regeln umfasst die Durchquerung des Binärbaums: rekursive Strukturdurchquerung vor der Bestellung/in der Reihenfolge/nach der Bestellung
1. Vorbestellungsdurchquerung (Vorbestellungsdurchquerung, auch als Vorbestellungsdurchquerung bekannt) – Der Vorgang des Besuchs des Wurzelknotens erfolgt vor dem Durchlaufen seiner linken und rechten Teilbäume. Zugriffsreihenfolge – Wurzel -> linker Teilbaum -> rechter Teilbaum
2. Inorder-Traversal (Inorder-Traversal) – Der Vorgang des Besuchs des Wurzelknotens erfolgt beim Durchqueren seines linken und rechten Teilbaums (zwischen).
Zugriffsreihenfolge – linker Teilbaum -> Wurzel -> rechter Teilbaum
3. Postorder Traversal – Der Vorgang des Besuchs des Wurzelknotens erfolgt nach dem Durchlaufen seiner linken und rechten Teilbäume.
Zugriffsreihenfolge – linker Teilbaum -> rechter Teilbaum -> Wurzel
Beispiel
1.2 Implementierung des Traversalcodes vor, in der Bestellung und nach der Bestellung
1.2.1 Erstellen Sie einen binären Baumknoten
typedef int BTDataType;
typedef struct BinaryTreeNode
{
struct BinaryTreeNode* left; //左子树
struct BinaryTreeNode* right;//右子树
BTDataType data;//数据
}BTNode;1.2.2 Erstellen Sie manuell einen Binärbaum
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef int BTDataType;
typedef struct BinaryTreeNode
{
struct BinaryTreeNode* left;
struct BinaryTreeNode* right;
BTDataType data;
}BTNode;
BTNode* BuyNode(BTDataType x)
{
BTNode* node = (BTNode*)malloc(sizeof(BTNode));
assert(node);
node->data = x;
node->left = NULL;
node->right = NULL;
return node;
}
BTNode* CreatBinaryTree() //搓树
{
BTNode* node1 = BuyNode(1);
BTNode* node2 = BuyNode(2);
BTNode* node3 = BuyNode(3);
BTNode* node4 = BuyNode(4);
BTNode* node5 = BuyNode(5);
BTNode* node6 = BuyNode(6);
node1->left = node2;
node1->right = node4;
node2->left = node3;
node4->left = node5;
node4->right = node6;
return node1;
}
void PreOrder(BTNode* root) //前序遍历
{
if (root == NULL)
{
printf("# ");
return;
}
printf("%d ", root->data);
PreOrder(root->left);
PreOrder(root->right);
}
void InOrder(BTNode* root)//中序遍历
{
if (root == NULL)
{
printf("# ");
return;
}
InOrder(root->left);
printf("%d ", root->data);
InOrder(root->right);
}
void PostOrder(BTNode* root)//后序遍历
{
if (root == NULL) {
printf("# ");
return;
}
PostOrder(root->left);
PostOrder(root->right);
printf("%d ", root->data);
}
int main()
{
BTNode* root = CreatBinaryTree();
PreOrder(root);//前序遍历
printf("\n");
InOrder(root);//中序遍历
printf("\n");
PostOrder(root);//后序遍历
printf("\n");
return 0;
}
1.2.3 Code-Ergebnisse
1.2.4 Rekursiver Expansionsgraph
(Um die Kettenstruktur eines Binärbaums zu lernen, müssen Sie lernen, ein rekursives Erweiterungsdiagramm zu zeichnen.)
Hinweis: Beim Zugriff auf einen leeren Baum beendet return die Rekursion nicht, sondern kehrt zu der Stelle zurück, an der die Funktion aufgerufen wird
Das Folgende ist das rekursive Erweiterungsdiagramm des linken Teilbaums, der in der Vorbestellung durchlaufen wird (das Prinzip des rechten Teilbaums ist dasselbe) 》》》
2. Ermitteln Sie die Anzahl der Binärbaumknoten
2.1 Die Art der globalen Zählung (nicht empfohlen)
Beim Schreiben von Code sollten globale Variablen so wenig wie möglich verwendet werden. Dies gilt auch hier. Die Verwendung globaler Variablen führt zu folgenden Problemen:
Wenn wir zweimal anrufen, verdoppelt sich die Anzahl
Code
int count = 0;
void TreeSize1(BTNode* root)
{
if (root == NULL)
{
return;
}
++count;
TreeSize1(root->left);
TreeSize1(root->right);
}
2.2 Übernehmen Sie die Idee des Teilens und Herrschens
Zerlegen Sie einen Binärbaum in drei Teile – Wurzelknoten, linker Teilbaum, rechter Teilbaum
Code:
int TreeSize2(BTNode* root)
{
return root == NULL ? 0 :
TreeSize2(root->left) + TreeSize2(root->right) + 1;
}
rekursiver Expansionsgraph
Hinweis: Der Binärbaum hier unterscheidet sich vom obigen (die Berechnungsmethode ist jedoch ungefähr dieselbe).
Die Zahlen in Blau sind die rekursive Reihenfolge
Die rote Zahl 1 gibt die Anzahl der zurückgegebenen Knoten an – schließlich gibt der linke Teilbaum 3 zurück, der rechte Teilbaum gibt 3 zurück, +1, und es gibt insgesamt 7 Knoten (es ist ersichtlich, dass bei rekursiver Rückgabe +1 hinzugefügt wird).
3. Ermitteln Sie die Anzahl der Blattknoten im Binärbaum
Ideenanalyse
Was ist ein Blattknoten? -> Die linken und rechten untergeordneten Knoten sind alle leere Knoten , so wie die Anzahl der Knoten im Binärbaum oben 3 beträgt
So steuern Sie es ——> 1. Der Binärbaum ist ein leerer Baum
2. Der Binärbaum hat nur einen Wurzelknoten (dh der linke und der rechte Teilbaum sind leer).
3. Wenn Sie den dritten Punkt erreicht haben, rekursieren Sie direkt auf leer, rekursiv auf leer, geben Sie dann den zweiten Punkt ein und geben Sie 1 zurück
Code
int TreeLeafSize(BTNode* root)
{
if (root == NULL)
return 0;
if (root->left== NULL && root->right == NULL)
return 1;
return TreeLeafSize(root->left) + TreeLeafSize(root->right);
}4. Ermitteln Sie die Anzahl der Knoten in der k-ten Schicht des Binärbaums
Ideenanalyse
Methode: Konvertieren Sie in das kleinste Teilproblem
Idee: Finden Sie den Knoten der k-ten Schicht und konvertieren Sie ihn in die k-1-te Schicht des linken Teilbaums + die k-1-te Schicht des rechten Teilbaums
Bei jeder Rekursion ist k -1. Wenn k = 1 ist, wird 1 zurückgegeben (es ist auch ersichtlich, dass k nicht auf 0 reduziert werden kann).
Hinweis 1: k kann hier nicht in der Form von k-- geschrieben werden. Wenn k-- bei der Rekursion des linken Teilbaums verwendet wird, wird k geändert und es treten Probleme bei der Rekursion des rechten Teilbaums auf
Hinweis 2: Sagen Sie wichtige Dinge dreimal! ! ! return ist der Ort, an dem die Funktion aufgerufen wird, nicht das Ende der Rekursion
Code
int TreeKLevel(BTNode* root, int k)
{
assert(k >= 1);
if (root == NULL)
return 0;
if (k == 1)
return 1;
return TreeKLevel(root->left, k - 1)
+ TreeKLevel(root->right, k - 1);
}
Rekursives Erweiterungsdiagramm (teilweise)
Es gibt viele Wissenspunkte zu verketteten Binärbäumen, daher wird Xiaoyu es hier in zwei Teilen schreiben. Wenn Sie interessiert sind, können Sie auf meine nächste Ausgabe warten! ! !
Wenn Sie der Meinung sind, dass der Artikel gut ist, freue ich mich über Ihren One-Click-Triple-Link. Ihre Ermutigung ist die Quelle der Motivation für meine Kreation. Lassen Sie uns zusammenarbeiten und wir sehen uns an der Spitze! ! !