So implementieren Sie Binärbaum in C?

Ein Baum ist ein gemeinsames Datenformat zum Speichern von Informationen, die hierarchisch enthalten sind. Ein Baum besteht aus Knoten, die durch Kanten verknüpft sind, wobei jeder Knoten seinen übergeordneten Knoten und einen oder mehrere untergeordnete Knoten hat. Dieser Artikel untersucht und analysiert Binärbäume und sieht die Umsetzung von Binärbäume In C -Programmierung.

Binärer Baum in c

In c, a Binärbaum ist eine Instanz einer Baumdatenstruktur mit einem übergeordneten Knoten, der möglicherweise eine maximale Anzahl von zwei untergeordneten Knoten besitzt; 0, 1 oder 2 Nachkommenknoten. Jeder einzelne Knoten in a Binärbaum hat einen eigenen Wert und zwei Zeiger auf seine Kinder, einen Zeiger für das linke Kind und das andere für das rechte Kind.

Binärbaumerklärung

A Binärbaum kann in C unter Verwendung eines Objekts namens deklariert werden Struktur Das zeigt einen der Knoten im Baum.

Strukturknoten
DataType var_name;
Strukturknoten* links;
Strukturknoten* rechts;
;

Oben ist eine Erklärung von einem Binärbaum Knotenname als Knoten. Es enthält drei Werte; Einer ist die Datenspeichervariable und die anderen beiden sind die Zeiger für das Kind. (Links und rechtes Kind des übergeordneten Knotens).

Fakten des binären Baumes

Auch für große Datensätze mit a Binärbaum erleichtert und schneller die Suche. Die Anzahl der Bäste ist nicht begrenzt. Im Gegensatz zu einem Array können Bäume jeglicher Art hergestellt und erhöht werden, basierend auf dem, was von einer Person verlangt wird.

Implementierung von Binärbäumen in C

Das Folgende ist eine Schritt-für-Schritt-Anleitung zur Implementierung a Binärbaum in c.

Schritt 1: Deklarieren Sie einen binären Suchbaum

Erstellen Sie einen Struct -Knoten mit drei Arten von Daten, wie z.

Strukturknoten

int Daten;
struct node *right_child;
struct node *links_child;
;

Schritt 2: Erstellen Sie neue Knoten im binären Suchbaum

Erstellen Sie einen neuen Knoten, indem Sie eine Funktion erstellen, die eine Ganzzahl als Argument akzeptiert und den Zeiger auf den mit diesem Wert erstellten neuen Knoten liefert. Verwenden Sie die malloc () -Funktion in c für die dynamische Speicherzuweisung für den erstellten Knoten. Initialisieren Sie das linke und rechte Kind in Null und geben Sie den Knotenname zurück.

Struct Node* create (Datentypdaten)

struct node* nodename = malloc (sizeof (struct node));
nodhename-> data = value;
nodhename-> links_child = nodhename-> right_child = null;
Return KnodeName zurückgeben;

Schritt 3: Einlegen Sie die rechte und linke Kind in Binärbaum

Erstellen von Funktionen Insert_Left und Insert_Right, die zwei Eingänge akzeptieren, die der Wert sind, der eingefügt wird, und der Zeiger auf den Knoten, an den beide Kinder verbunden sind. Rufen Sie die Funktion erstellen, um einen neuen Knoten zu erstellen, und weisen Sie den zurückgegebenen Zeiger dem linken Zeiger des linken Kindes oder dem rechten Zeiger des rechten Kindes des Stammerteils zu.

struct node* insert_left (struct node* root, Datentypdaten)
root-> links = create (Daten);
Root-> links zurückgeben;

struct node* insert_right (struct node* root, Datentypdaten)
root-> right = create (data);
Return Root-> Right;

Schritt 4: Zeigen Sie Knoten des binären Baums mithilfe von Traversalmethoden an

Wir können Bäume mit drei Methoden des Traversals in C anzeigen. Diese Traversalmethoden sind:

1: Vorbestellung durchträgt

In dieser Traversal -Methode gehen wir die Knoten in eine Richtung von durch parent_node-> links_child-> right_child.

void Pre_order (Knoten * root)
if (root)
printf ("%d \ n", root-> data);
display_pre_order (root-> links);
display_pre_order (root-> rechts);

2: Nachbestellung durch den Bestellung

In dieser Traversal -Methode werden wir die Knoten in eine Richtung von der durchlaufen links_child-> right_child-> parent_node->.

void display_post_order (knoten * root)
if (binary_tree)
display_post_order (root-> links);
display_post_order (root-> rechts);
printf ("%d \ n", root-> data);

3: In-Ordnung-Traversal

In dieser Traversal -Methode gehen wir die Knoten in eine Richtung von durch links_node-> root_child-> right_child.

void display_in_order (knoten * root)
if (binary_tree)
display_in_order (root-> links);
printf ("%d \ n", root-> data);
display_in_order (root-> rechts);

Schritt 5: Löschung im binären Baum durchführen

Wir können das Erstellen löschen Binärbaum Durch das Löschen der Kinder mit der übergeordneten Knotenfunktion in C wie folgt wie folgt.

void Delete_t (Knoten * root)
if (root)
delete_t (root-> links);
delete_t (root-> rechts);
frei (Wurzel);

C Programm des binären Suchbaums

Das Folgende ist die vollständige Implementierung des binären Suchbaums in der C -Programmierung:

#enthalten
#enthalten
Strukturknoten
int Wert;
Strukturknoten * links, * rechts;
;
struct node * node1 (int data)
struct node * tmp = (struct node *) malloc (sizeof (struct node));
tmp -> value = data;
tmp -> links = tmp -> rechts = null;
TMP zurückgeben;

Hohlraumdruck (Struct -Knoten * root_node) // Anzeigen der Knoten!

if (root_node != Null)
print (root_node -> links);
printf ("%d \ n", root_node -> value);
print (root_node -> rechts);


Struct -Knoten * Insert_node (Struct -Knoten * Knoten, int data) // Einfügen von Knoten einfügen!

if (node ​​== null) return node1 (data);
if (Daten < node -> Wert)
Knoten -> links = insert_node (Knoten -> links, Daten);
else if (Data> Knoten -> Wert)
Knoten -> rechts = insert_node (Knoten -> rechts, Daten);

Return Node;

int main ()
printf ("c Implementierung von Binär -Suchbaum!\ n \ n ");
struct node * parent = null;
parent = insert_node (übergeordnet, 10);
insert_node (übergeordnet, 4);
insert_node (übergeordnet, 66);
insert_node (übergeordnet, 45);
insert_node (übergeordnet, 9);
insert_node (übergeordnet, 7);
Druck (Eltern);
Rückkehr 0;

Im obigen Code deklarieren wir zuerst a Knoten Verwendung Struktur. Dann initialisieren wir einen neuen Knoten als “Node1Und den Speicher dynamisch verwenden malloc () in C mit Daten und zwei Zeiger Typ Kinder mit dem deklarierten Knoten angeben. Danach zeigen wir den Knoten vorbei printf () Funktion und nennen Sie es in der hauptsächlich() Funktion. Dann ist die Insertion_node () Die Funktion wird erstellt, wobei, wenn Knotendaten null sind, dann null ist Node1 ist im Ruhestand, sonst werden Daten in die platziert Knoten(Elternteil) des linken und rechten Kindes. Das Programm beginnt die Ausführung von der hauptsächlich() Funktion, die einen Knoten erzeugt, der einige Beispielknoten als Kinder verwendet und dann in Ordnung mit durchqueren.

Ausgang

Abschluss

Bäume werden häufig verwendet, um Daten in nichtlinearer Form zu halten. Binärbäume sind Arten von Bäumen, bei denen jeder Knoten (Elternteil) zwei Nachkommen im linken Kind und das rechte Kind hat. A Binärbaum ist eine vielseitige Methode zum Übertragen und Speichern von Daten. Es ist effizienter im Vergleich zur Verbindungsliste in C. Im obigen Artikel haben wir das Konzept von a gesehen Binärbaum mit der Schritt-für-Schritt-Implementierung von a Binärer Suchbaum in c.