Rundschreiben verknüpfte Liste in C ++

Wir können Elemente von überall in der Liste von überall in die kreisförmige Liste einfügen. Wir können jedoch keine Elemente von überall in der Liste in das Array einfügen, da es sich in einem zusammenhängenden Speicher befindet. Das letzte Element in einer kreisförmigen verknüpften Liste hält die Adresse des nächsten Elements, während das letzte Element die Adresse des ersten Elements behält. Eine kreisförmige Kette wird durch die Elemente gebildet, die sich in einem kreisförmigen Muster aufeinander beziehen.

Da die kreisförmige verknüpfte Liste eine dynamische Größe hat, kann der Speicher nur dann zugewiesen werden, wenn sie benötigt wird. Der Artikel demonstriert die kreisförmig verknüpfte Liste mit den C ++ - Programmabbildungen in C++.

Anwendung der kreisförmigen verknüpften Liste

Eine kreisförmige verknüpfte Liste ist eine, in der alle Knoten in einem Kreis verbunden sind. Es gibt kein Nullelement in der kreisförmigen verknüpften Liste. Ein Anfangspunkt kann jeder Knoten sein. Ab jeder Stelle in der Liste können wir die gesamte Liste durchqueren. Alles, was wir jetzt tun müssen, ist zu warten, bis der erste Knoten wieder erreicht ist. Dort haben wir einige Anwendungen einer kreisförmigen verlinkten Liste wie folgt:

1. Unsere Personalcomputer, die mehrere Apps ausführen, sind ein Beispiel dafür. Alle laufenden Apps werden in einer kreisförmigen verknüpften Liste gespeichert, und das Betriebssystem weist jedem einen bestimmten Zeitfenster zum Ausführen zu. Das Betriebssystem läuft weiter über die verknüpfte Liste, bis alle Programme ausgeführt werden.
2. Multiplayer -Spiele sind ein weiteres hervorragendes Beispiel. Alle Spieler werden in einer kreisförmigen verlinkten Liste gespeichert, wobei der Zeiger voranschreitet, wenn die Gelegenheit jedes Spielers abläuft.
3. Die kreisförmige Warteschlange kann auch mit einer kreisförmigen verlinkten Liste erstellt werden. Wir müssen in einer Warteschlange zu jeder Zeit sowohl die Hinweise vorne und hinten im Speicher behalten, aber es wird nur ein Zeiger in einer kreisförmigen verlinkten Liste benötigt.

Beispiel 1: Erstellen einer kreisförmigen verknüpften Liste in C++

Der einzige Unterschied besteht Aufführen. Die Implementierung der kreisförmigen verknüpften List -Traversal -Code in C ++ ist unten angezeigt.

Im ersten Schritt haben wir eine Klasse als "Knoten" definiert, in der wir eine int -Variable als "mydata" deklariert haben. Die Variable „mydata“ ist die Daten für den Knoten. Der Zeiger wird in dieser Klasse auch als "als nächst" für den Zeiger auf den nächsten Knoten in der kreisförmigen verlinkten Liste deklariert.

Nach der Klasse "Knoten" haben wir eine Funktion namens "Push", die den Knoten am Anfang der kreisförmigen verknüpften Liste einfügt. Wir haben den Konstruktor definiert, der die Head_Node -Zeigerreferenz der Klasse „Knoten“ und die Variable „mydata“ als Parameter übergibt. Der neue Zeiger wird als "MyPTR" erstellt, der den "Knoten" angerufen und zugewiesen hat und zugewiesen hat und zugewiesen hat und zugewiesen hat.

Dann wird der Temperaturzeiger als "Temp" deklariert, der den Head_Node hat. Es gibt Zeiger wie "PTR1" und "PTR2", die "Mydata" und Zeiger "Weiter" genannt werden und ihre Adressen annehmen. Danach haben wir eine IF -Anweisung, in der es nur head_node gibt, und es wird null gehalten. Wenn die kreisförmige verknüpfte Liste null ist, fügen Sie den nächsten zum letzten Knoten mit Hilfe einer Weile -Schleife hinzu. Andernfalls wird die elsee Anweisung ausgeführt, in der der Kopf auf den ersten Knoten der Liste zeigt.

Dann haben wir eine andere Funktion als „Anzeigeliste“ erstellt und im Konstruktor dieser Funktion haben wir gerade den Knotenkopf der kreisförmigen verknüpften Liste übergeben. Die Funktion zeigt die Knoten in einer kreisförmigen Liste über eine Do-While-Schleife nach der IF-Anweisung an, die die Bedingung hat, dass der Kopf des Knotens nicht gleich Null sein sollte.

Schließlich gibt es die Hauptmethode, die die zuvor beschriebene Implementierung testet. Der Zeigerkopf des Klasse „Knoten“ wurde in der Hauptmethode auf „Null“ eingestellt. Fügen Sie dann die Daten mit Hilfe der PUSP () -Methode zur verlinkten Liste hinzu. Der „Kopf“ wird an die Funktion „DisplayList“ übergeben, die die kreisförmige verknüpfte Liste anzeigt.

#enthalten
Verwenden von Namespace STD;
Klassenknoten

öffentlich:
int mydata;
Knoten *Weiter;
;
void push (Knoten ** head_node, int mydata)

Node *myptr1 = neuer node ();
Node *temp = *head_node;
Myptr1-> mydata = mydata;
Myptr1-> next = *head_node;
if (*head_node != Null)

while (temp-> als nächstes != *head_node)
temp = temp-> Weiter;
temp-> next = myptr1;

anders
Myptr1-> next = myptr1;
*head_node = myptr1;

Void Displaylist (Knoten *Kopf)

Knoten *temp = Kopf;
if (Kopf != Null)

Tun

Cout
while (temp != Kopf);


int main ()

Knoten *head = null;
Push (& Head, 2001);
Push (& Head, 2015);
Push (& Head, 2006);
Push (& Head, 2022);
Cout<< "Circular Linked List:\n ";
Displaylist (Kopf);
Cout<< "\n ";
Rückkehr 0;

Die in der obigen Codeausgabe implementierte kreisförmige verknüpfte Liste wird im folgenden Bild angezeigt.

Beispiel2: Teilen Sie die kreisförmige verknüpfte Liste in zwei Hälften in c++

Das folgende Programm ermöglicht die Aufteilung einer kreisförmigen verknüpften Liste in zwei Teile möglich. Schauen wir uns die Implementierung an, wie wir die kreisförmige verlinkte Liste in C aufgeteilt haben++.

Erstens haben wir einen Klasse „Knoten“, in dem wir eine Variable „Elemente“ und den Zeiger „Weiter“ des Knotens definiert haben. Die Mitglieder der Klasse „Knoten“ sind in diesem Programm öffentlich. Dann haben wir eine Funktion namens „Halvelist“ erstellt, in der wir die Liste von Anfang an mit dem Kopf in zwei Listen aufgeteilt haben. Der Head1_Node und Head2_Node sind Verweise auf die beiden resultierenden verknüpften Listen -Kopfknoten.

In der Funktion haben wir zwei Zeiger deklariert, "S_PTR" und das "F_PTR", das den Kopf der verknüpften Liste hat. Wenn die IF-Anweisung für den Kopfknoten verwendet wird, der einen Nullwert enthält Die Liste enthält sogar Knoten.

Nach der while -Schleife haben wir erneut die IF -Anweisung verwendet, in der die Bedingung lautet: „Wenn die Liste gleiche Elemente enthält, sollte F_PTR verschoben werden und den Head1_Node -Zeiger der ersten Hälfte festlegen“. In der nächsten Anweisung haben wir den Head2_Node auf die zweite Hälfte der verknüpften Liste gesetzt.

Wir haben neben dem F_PTR-> SPTR-> neben dem F_PTR-> zugewiesen, um die zweite Halbzirkular der Liste zu erstellen, und dann wird S_PTR-> gleich dem Kopf der Liste gehalten und macht den ersten Halbkreis.

Die zweite Funktion wird als "Push" erstellt, der zum Einfügen eines Knotens zu Beginn einer kreisförmigen verknüpften Liste mit dieser Funktion verwendet wird. In der Funktion impliziert die Bedingung, ob der Head_Node der kreisförmigen verknüpften Liste nicht null ist, und dann neben dem letzten Knoten festgelegt. Die dritte Funktion, "DisplayList".

Dann haben wir die Hauptfunktion, bei der wir den Kopf, Head1_Node und Head2_Node leer initialisiert haben. Die Push -Methode wird verwendet, um die Werte in die verlinkte Liste einzufügen, und über den COUT.

#enthalten
Verwenden von Namespace STD;
Klasse Mynode

öffentlich:
int Artikel;
Mynode *Weiter;
;
void Halvelist (MyNode *Kopf, myNode ** head1_node, mynode ** head2_node)

Mynode *s_ptr = Kopf;
Mynode *f_ptr = Kopf;
if (head == null)
zurückkehren;
while (f_ptr-> Weiter != Kopf &&
F_PTR-> Weiter-> Weiter != Kopf)

F_PTR = F_PTR-> NEXT-> NEXT;
s_ptr = s_ptr-> Weiter;

if (f_ptr-> next-> next == Kopf)
f_ptr = f_ptr-> Weiter;
*head1_node = head;
if (head-> Weiter != Kopf)
*head2_node = s_ptr-> Weiter;
f_ptr-> next = s_ptr-> next;
s_ptr-> next = head;

void push (mynode ** head_node, int items)

Mynode *newptr = new myNode ();
Mynode *temp = *head_node;
Newptr-> items = items;
Newptr-> next = *head_node;
if (*head_node != Null)

while (temp-> als nächstes != *head_node)
temp = temp-> Weiter;
temp-> next = newptr;

anders
Newptr-> next = newptr; / *Für den ersten myNode */
*head_node = newptr;

Void Displaylist (Mynode *Kopf)

Mynode *temp = Kopf;
if (Kopf != Null)

Cout<Tun
Cout while (tempep != Kopf);


int main ()

int mylistize, ich;
Mynode *head = null;
Mynode *head1 = null;
Mynode *head2 = null;
Push (& Head, 10);
Push (& Head, 90);
Push (& Head, 40);
Push (& Head, 70);
Cout<< "Circular Linked List";
Displaylist (Kopf);
Halvelist (Head & Head1, & Head2);
Cout<< "\nFirst Halve Circular Linked List";
Displaylist (Head1);
Cout<< "\nSecond Halve Circular Linked List";
Displaylist (Head2);
Rückkehr 0;

Hier haben wir die Ausgabe der ursprünglichen, kreisförmigen Liste, die Ausgabe der ersten halbkreisförmigen verlinkten Liste und die zweite Hälfte der kreisförmigen verknüpften Liste.

Beispiel 3: Sortieren der kreisförmigen verknüpften Liste in C++

Im ersten Schritt haben wir eine Klasse „Nodelist“, die Mitgliedsvariablen und Zeiger in der Klasse enthält. Anschließend haben wir eine Funktion „SortInsertion“ erstellt, die einen neuen Knoten in eine sortierte Liste einfügt. Diese Funktion erfordert einen Zeiger auf den Kopfknoten, da er den Kopf der Linked Licted List ändern kann.

Danach haben wir eine IF -Anweisung für Nodelist, die nur einen Knoten darin enthält. Der Head_Node verweist auf den neuen Knoten. In der elenden Anweisung haben wir die Daten des Nodelists dem Strom zugewiesen.

Hier wird ein neuer Knoten vor dem Kopfknoten hinzugefügt. Der IF-ELSE-Block hat eine Weile Schleife, die einen Zustand hat; Wenn der Wert geringer ist als der Kopfwert, muss der nächste oder letzte Knoten geändert werden. Die while -Schleife identifiziert nur den Knoten vor dem Einfügenpunkt.

Danach haben wir einen New_Nodelist gemacht, den nächsten Knoten, der den nächsten Knoten des Zeigers lokalisiert. Dann müssen wir als nächstes den Standort des Zeigers zum nächsten ändern. Um die Knoten der verknüpften Liste zu drucken, haben wir eine Funktion "Showlist" bezeichnet,.

Am Ende haben wir die Hauptfunktion, in der wir ein Array initialisiert und über das angegebene Array iteriert wurden, das ein sortiertes Array ist.

#enthalten
Verwenden von Namespace STD;
Klasse Nodelist

öffentlich:
int Werte;
Nodelist *Weiter;
;
void sortInsertion (nodelist ** head_node, nodelist* new_nodelist)

Nodelist * current = * head_node;
if (current == null)

new_nodelist-> next = new_nodelist;
*head_node = new_nodelist;

else if (aktuelle-> Werte> = new_nodelist-> Werte)

while (aktuell-als nächstes != *head_node)
Strom = Strom-> Weiter;
aktuell-> next = new_nodelist;
new_nodelist-> next = *head_node;
*head_node = new_nodelist;

anders

while (aktuell-als nächstes!= *head_node &&
Strom-> Weiter-> Werte)
Strom = Strom-> Weiter;
new_nodelist-> next = current-> Weiter;
aktuell-> next = new_nodelist;


void showlist (nodelist *beginnen)

Nodelist *temp;
if (beginnen != Null)

temp = begin;
Tun
Cout while (tempep != Beginnen Sie);


int main ()

int myarr [] = 31, 5, 23, 99, 30;
int list_size, i;
Nodelist *begin = null;
Nodelist *temp;
für (i = 0; Ivalues ​​= myarr [i];
SortInsertion (& beginne, temp);

Cout<<"Sorted Circular Linked List:\n";
Showlist (Beginn);
Cout<<"\n";
Rückkehr 0;

Die sortierte kreisförmige verlinkte Liste wird auf dem folgenden Bildschirm von Ubuntu angezeigt.

Abschluss

Dadurch wird unsere Diskussion darüber beendet++. In vielen Anwendungen, die viel Flexibilität erfordern. Ich hoffe, dies hilft Ihnen dabei, Unklarheiten im Zusammenhang mit der kreisförmigen verlinkten Liste in C zu entfernen++.