Drucklinkliste in C ++ drucken

Wenn es darum geht, Datenelemente dynamisch zu speichern, ähneln verknüpfte Listen einem Array. Ein Array ist eine lineare Datenstruktur, die alle Datenelemente speichert, sodass wir die Elemente des Arrays in einem kontinuierlichen Betrieb übertragen können. Während Datenelemente in der verknüpften Liste nicht an kontinuierlichen Speicherorten gehalten werden, wenn sie gespeichert werden. Es gibt den Ausgangspunkt in der verlinkten Liste, die als Kopf bezeichnet wird, und der Endpunkt wird als Schwanz der verknüpften Liste in C ++ - Programmiersprache bezeichnet. In einer verknüpften Liste gibt es Knoten, die Datenobjekte darin speichern. Der Knoten hat zwei Teile: Das Teil enthält das Datenobjekt an sich und der zweite Teil enthält den Zeiger auf den Knoten danach. Der letzte Knoten der verknüpften Liste enthält den Nullzeiger.

Wir verwenden eine verknüpfte Liste, wenn wir ein Array zum Speichern der Daten haben, da wir in Arrays die Länge des Arrays während der Erklärung des Arrays mitteilen müssen. In verknüpften Listen ist die Größe jedoch kein Problem mehr. Die Länge der verknüpften Liste wird erweitert, wenn das Programm erforderlich ist, die Liste jedoch durch die verfügbare Speicherkapazität des Speichers eingeschränkt wird. Die verknüpfte Liste kann mehrere Vorgänge in der C ++ - Sprache ausführen, nämlich: Einfügen, Löschen, Durchqueren, Such- und Sortiervorgänge. Um diese Operationen der Linkliste zu verstehen, lassen Sie uns das Beispiel implementieren und verstehen, wie eine verknüpfte Liste in C ++ - Programmiersprache funktioniert. Wir untersuchen auch, wie diese Operationen in der verlinkten Liste funktionieren.

Beispiel:

Lassen Sie uns nun das verknüpfte Listenbeispiel der C ++ - Programmiersprache der C ++ entwickeln. Starten Sie den Compiler und beginnen Sie mit dem Schreiben von Code, um das Beispiel in die Praxis umzusetzen. Wir müssen die Header-Datei einfügen, nachdem wir den Übersetzer ausgeführt haben, um sie einfach und einfach auf die integrierten Methoden, Klassen und andere Komponenten zuzugreifen, die wir in das C ++-Programmiersprachenprogramm aufnehmen möchten.

#enthalten
#enthalten
Verwenden von Namespace STD;

Das „iOstream“ -Paket ist das erste grundlegende Paket in C ++ und wird von allen Programmen verwendet, da Benutzer Eingaben- und Ansichtsausgabe bereitstellen können. Der zweite Standard -Bibliotheksheader “stdlib.H ”liefert zuverlässige und effektive Routinen für die Zuweisung von Speicher dynamisch an C ++ - Programmierer. Das "#" -Schild weist den Dolmetscher an, die Pakete abzurufen, gefolgt vom Schlüsselwort "einschließlich", und fordert es auf, die Bibliothek zu integrieren. Schließlich ist der Bibliotheksname in den „“ -Token geschrieben. Der letzte Satz "Verwendung von Namespace STD" ist erforderlich, um einen Kontext für den Code bereitzustellen.

Initialisierung der Struktur

Als nächstes erstellen wir die Struktur des Namens „Knoten“, damit wir den Knoten der verknüpften Liste gebildet haben. Nach dem Erstellen des Knotens deklarieren wir die Teile des Knotens in der Struktur. In dem ersten Teil des Knotens speichern wir die Datenelemente. Wir haben also eine Ganzzahl-Variable „Info“ deklariert, um die Datenelemente zu speichern. Der nächste Teil ist eine Zeigervariable „Follownode“, die den Zeiger in die nächste Follownode in der verknüpften Liste bewegt. Die Einzelheiten sind wie folgt:

Strukturknoten

int info;
struct node* follownode;
;

Einfügen von Datenelementen in die verknüpfte Liste

Wir haben mehrere Funktionen erstellt, damit wir die Datenelemente in die verknüpfte Liste einfügen können, die wir in C ++ - Programmiersprache erstellen möchten.

Beg_insert () Funktion:

Wir haben eine benutzerdefinierte Funktion in der C ++-Programmiersprache erstellt, die die Funktion Beg_insert () ist. Wie der Name schon sagt, werden wir diese Funktion verwenden, um die Daten zu Beginn der verknüpften Liste einzufügen. Die Funktion bett_insert () nimmt zwei Argumente auf. Als Nächst. Der „CUR -Knoten“ wird dann mit dem Parameter „Neuen Info“ initialisiert und sein Zeiger wird auf den Kopf der Connected List gesetzt. Mit der Referenz "Kopfinformationen" wird der Kopf der verknüpften Liste zunächst in den "CUR -Knoten" gelistet, der zunächst gelistet ist.

void bett_insert (struct node ** head_info, int new_info)

struct node* cur_node = (struct node*) malloc (sizeof (struct node));
cur_node-> info = new_info;
cur_node-> follownode = (*head_info);
(*head_info) = cur_node;

Mid_insert () Funktion:

Jetzt haben wir eine weitere Funktion erstellt, um die Datenelemente in der Mitte der LIGEDED -Liste einzugeben, die die Funktion von Mid_insert () ist. In der MID () -Funktion müssen wir zwei Argumente aufnehmen, die "pre_node" sind, der Zeiger des "Knoten" -Typs ist, und "new_info" die Variable, die die neuen Daten in sich selbst des Ganzzahl -Typs speichert. Wir haben die Anweisung "if" verwendet, um den "pre_node wenn es null ist oder nicht in der Funktionskörper. Dann haben wir einen "nächsten" Zeiger des "new_info" erstellt, der auf den nächsten Knoten des "Pre_Node" hinweist.

void Mid_insert (Struct Node* Pre_Node, int new_info)

if (pre_node == null)

Cout << "The Previous Node Can't be NULL";
zurückkehren;

struct node* cur_node = (struct node*) malloc (sizeof (struct node));
cur_node-> info = new_info;
cur_node-> follownode = pre_node-> follownode;
pre_node-> follownode = cur_node;

end_insert () Funktion:

Wir haben diese Funktion erstellt, damit wir die Datenelemente am Ende der verknüpften Liste eingeben können. Wir haben die gleichen Argumente erklärt, wie wir in der Funktion bett_insert () deklariert haben. Diese Funktion überprüft zuerst, ob die Liste leer ist oder nicht. Stellen Sie die „neuen Informationen“ am Anfang der Liste ein und geben Sie sie zurück, wenn die Liste auch null war. Wenn es sich nicht um Null handelt, wird die Prozedur durch die Liste fortgesetzt, bis es auf den Knoten "Last Knode" trifft. Die "neuen Infos" wird dann als "letzter Knoten" -Knoten am Ende der Liste hinzugefügt.

void end_insert (struct node ** head_info, int new_info)

struct node* cur_node = (struct node*) malloc (sizeof (struct node));
struct node * last_node = * head_info;
cur_node-> info = new_info;
cur_node-> follownode = null;
if (*head_info == null)

*head_info = cur_node;
zurückkehren;

while (last_node-> follownode != Null)

last_node = last_node-> follownode;
last_node-> follownode = cur_node;
zurückkehren;

Einen Knoten aus einer verknüpften Liste herausnehmen

Um die vorliegenden Knoten aus der verknüpften Liste zu entfernen, haben wir jetzt eine neue Methode namens Delete Node () erstellt. Es bestimmt zunächst, ob der Kopfknoten selbst den New_Key hat, der gelöscht werden muss. In diesem Fall wird der Kopfverweis auf den Follownode aktualisiert. Mit einer Schleife befindet sich der Knoten, der den zu zerstörten New_Key enthält. Wenn ein Knoten entdeckt wird. Schließlich wird die Funktion Free () verwendet, um den Speicher loszulassen.

void delete_node (struct node ** head_info, int new_key)

struct node *temp_var = *head_info, *pre;
if (temp_var != Null && temp_var-> info == new_key)

*head_info = temp_var-> follownode;
Free (temp_var);
zurückkehren;

while (temp_var != Null && temp_var-> Info != new_key)

pre = temp_var;
temp_var = temp_var-> follownode;

if (temp_var == null)

zurückkehren;

pre-> follownode = temp_var-> follownode;
Free (temp_var);

Suchen Sie den Knoten in der verknüpften Liste

Die Funktionssuche () nimmt zwei Argumente auf. Die Funktion durchquert die verknüpfte Liste und prüft, ob die Daten des aktuellen Knotens mit dem „new_key“ übereinstimmen. Wenn die Daten des "aktuellen" Knotens mit dem "new_key" übereinstimmen, gibt die Funktion wahr zurück. Wenn die Daten des "aktuellen" Knotens nicht mit dem "new_key" übereinstimmen, wechselt die Funktion zum Follownode. Wenn der „aktuelle“ Knoten null wird, gibt die Funktion falsch zurück.

BOOL -Suche (Strukturknoten ** head_info, int new_key)

struct node * current = * head_info;
während (aktuell != Null)

if (aktuell-> info == new_key)

zurückkehren;

Strom = Strom-> Follownode;

falsch zurückgeben;

Sortieren der Komponenten des Knotens in der verknüpften Liste

In der C ++ - Programmierung wird die Sort () -Methode verwendet, um die Mitglieder in der verlinkten Liste in zunehmender Reihenfolge zu ordnen. Erstens wird festgestellt, ob die Referenz „Kopfinformationen“ null ist. Wenn ja, kehren wir zurück. Danach wird die Liste mehrmals bis zur Beendigung der Schleife wiederholt. Überprüfen. Wenn ja, tauschen wir die Daten zwischen den beiden Knoten aus. Der "Index" -Knoten wird dann in den Follownode übertragen. Die Prozedur wird dann bis zur Fertigstellung der Liste wiederholt.

void sortieren (struct node ** head_info)

struct node *current = *head_info, *index = null;
int temp_var;
if (head_info == null)

zurückkehren;

anders

während (aktuell != Null)

INDEX = current-> follownode;
während (Index != Null)

if (aktuell-> info> index-> ​​info)

temp_var = current-> info;
aktuell-> info = index-> ​​info;
index-> ​​info = temp_var;

index = index-> ​​follownode;

Strom = Strom-> Follownode;

Zeigen Sie den Knoten in der verknüpften Liste an

Die Funktion display () nimmt einen Zeiger auf den Kopf der verknüpften Liste als Parameter. Danach durchläuft es die Liste und zeigt die Informationen jedes Knotens an. Wenn es in die Fertigstellung der Liste kommt, stoppt es.

Hohlraumanzeige (Strukturknoten* Knoten)

während (Knoten != Null)
G
Cout << node->die Info << " ";
node = node-> follownode;

Aufrufen der Funktionen in der Funktion main ()

Wir haben die main () -Funktion geschrieben, damit wir den Fahrercode des Programms in der Haupt- () -Funktionskörper schreiben können. Zunächst wird der Zeiger "head_val" auf null des "node" -Typs initialisiert. Dann haben wir die Einfügungsfunktionen bezeichnet, die wir global erstellt haben, und haben jede Funktion des Einfügung definiert und den Wert darin übergeben. Um die verknüpfte Liste im Konsolenfenster des Benutzers anzuzeigen, haben wir eine benutzerdefinierte Anzeige () -Funktion aufgerufen. Rufen Sie die sort () an, damit wir die Daten in der verknüpften Liste anordnen können. Um den Knoten aus der verknüpften Liste zu löschen, haben wir die Funktion Delete_Node () aufgerufen und die Datenelemente übergeben, die wir löschen möchten. Wenn wir ein Element des Knotens finden möchten, haben wir die Funktion Search () aufgerufen und das Element darin übergeben.

int main ()

struct node* head_val = null;
Beg_insert (& head_val, 34);
Beg_insert (& head_val, 10);
end_insert (& head_val, 48);
Mid_insert (head_val-> follownode, 72);
Cout << "*---Implementation of Linked List in C++---*" << endl;
Cout << "\nThe Input Linked list is: ";
display (head_val);
sort (& head_val);
Cout << "\n\nAfter Sorting the Input List: ";
display (head_val);
Cout << "\nAfter deleting an element: ";
Delete_node (& head_val, 48);
display (head_val);
Beg_insert (& head_val, 63);
Beg_insert (& head_val, 84);
end_insert (& head_val, 11);
Mid_insert (head_val-> follownode, 100);
Cout << "\n\nThe Updated Linked list is: ";
display (head_val);
sort (& head_val);
Cout << "\nAfter Sorting the Input List: ";
display (head_val);
int find_data;
Cout << "\n\nEnter the element which you want to find? ";
cin >> find_data;
if (such (& head_val, find_data))

Cout << "The element " << find_data << " is found… ";

anders

Cout << "The element " << find_data << " is not found… ";

Im Folgenden ist das C ++ - Programmiersprachenergebnis des Szenarios aus der obigen Zusammenstellung.

Abschluss

Die verknüpfte Liste in der C ++ - Programmiersprache und die Unterscheidung zwischen einem Array und einer verknüpften Liste wurden in diesem Artikel beide behandelt. Wir haben über die verschiedenen Operationen der verknüpften Liste gesprochen. Wir haben zuerst ein verknüpftes Listenszenario erstellt und dann jede Operation in der Abbildung mit einer umfassenden Beschreibung jeder Zeile von C ++ - Code erstellt.