So löschen Sie einen Knoten in einer verknüpften Liste C ++

Eine verknüpfte Liste ist im Grunde eine Kombination aus zwei Dingen: dem Informationsteil und dem Adressteil. Der Adressteil, der auch den Zeiger oder den nächsten Knotenlink bezeichnet wird, speichert die Adresse des nächsten Knotens. Die verknüpfte Liste ist im Grunde eine lineare Datenstruktur, die Daten dynamisch über Zeiger speichert, auf die vom vorherigen Knotenzeiger leicht zugegriffen werden kann.

Der Knoten der verknüpften Liste sieht folgt aus:

Im Vergleich zum Array ist die verknüpfte Liste keine sequentielle Datenstruktur, da es sich um eine dynamisch gespeicherte Datenstruktur handelt. Es speichert alle Daten in verschiedenen Speicherorten und wir können auf diese Daten über den Zeiger des Knotens zugreifen, der die Adresse der Daten speichert.

Diese Möglichkeit zum Speichern von Daten hat diese Vorteile:

1. Wir haben keine vordefinierte Speichergröße wie ein Array, was zu viel Speicherabfall führt.

2. Wenn wir in einem Array ein Zeitspeicher definieren, können wir es nicht gemäß unseren Anforderungen verringern oder erhöhen. In einer verknüpften Liste können wir jedoch die Knoten entsprechend unseren Anforderungen erhöhen oder verringern.

Die verknüpfte Liste sieht so aus:

Jede verknüpfte Liste hat einen Header -Knoten, der der erste Knoten der verknüpften Liste ist. und ein Heckknoten, der am Ende der verknüpften Liste vorhanden ist. Aus dem Heckknoten ist die verknüpfte Liste auf den nächsten Knoten vorbei, da sie die Nulladresse speichert, was nichts bedeutet. Wenn eine verknüpfte Liste nur einen Knoten hat, bedeutet dies, dass der Headerknoten und der Heckknoten gleich sind.

Löschen einer verknüpften Liste:

Wie unten angegeben, können wir einen Knoten auf drei Arten aus einer verknüpften Liste löschen:

1. Löschen Sie den ersten Knoten der verknüpften Liste

2. Löschen Sie den letzten Knoten der verknüpften Liste

3. Löschen Sie einen bestimmten Positionsknoten

Erklärung all dieser Konzepte:

Löschen Sie den ersten Knoten der verknüpften Liste (den Header -Knoten):-

Um den ersten Knoten aus der verknüpften Liste zu löschen. Dazu müssen wir das folgende Verfahren befolgen:

A. Wir müssen einen Zeiger erstellen (vorübergehend).

B. Die Adresse des Headerknotens wird in den Zeiger kopiert (temporär).

C. Jetzt haben wir die Adresse des Headerknotens gespeichert. So können wir den nächsten Knoten des Headers als einen verlinkten ersten Knoten deklarieren.

Das Löschen des ersten Knotens bedeutet, dass der Headerknoten einfach ist:

C ++ - Code zum Löschen des ersten Knotens aus der verlinkten Liste:

void deletelinkedListfirstnode ()

Knoten *temporarynode = neuer Knoten;
temporarynode = headnode;
headnode = headnode-> Weiter;
Temporarynode löschen;

Löschen des letzten Knotens (Heckknoten):

Das Löschen des Headerknotens der verknüpften Liste war einfach. Wenn wir jedoch den letzten Knoten oder den Heckknoten der verknüpften Liste löschen wollten, müssen wir den Nullzeiger vom Heckknoten auf den vorherigen Knoten des Schwanzes übertragen, der die Adresse des Heckknotens hat.

Um dies zu implementieren, müssen wir zwei temporäre Knoten verwenden und durch die verknüpfte Liste laufen. Wenn die verlinkte Liste der durchquerligen, zeigt der einzige temporäre Knoten auf den aktuellen Knoten, und ein anderer temporärer Knoten zeigt auf den vorherigen Knoten. Jetzt adenden beiden erforderlichen Knoten die Details, die wir haben, und wir können den Heckknoten löschen, während wir den Nullzeiger auf den vorherigen Knoten verschieben.

C ++ - Code zum Löschen des letzten Knotens aus der verlinkten Liste:

void deletelinkedListLastnode ()

node *curralNode = neuer Knoten;
node *vorhernode = neuer Knoten;
currentNode = headnode;
while (currentNode-> Weiter!= Null)

vorhernode = currentNode;
Current = currentNode-> Weiter;

tail = vorhernode;
Vorher-Node-> next = null;
Stromnode löschen;

Löschen des Knotens an einer bestimmten Position:

Um einen Knoten von überall in der verlinkten Liste zu löschen, müssen wir die jeweilige Position des Knotens eingeben, den wir löschen möchten. Um den spezifischen Positionsknoten zu definieren, verwenden wir zwei temporäre Knoten, wie wir es beim Löschen des Heckknotens getan haben. Wir durchqueren die gesamte verknüpfte Liste, bis wir nicht den spezifischen Positionsknoten erhalten, den wir löschen möchten, und nachdem wir diesen Knoten erhalten haben. Da wir nun beide Knotendetails haben, können wir die Adresse einfach vom Löschknoten auf den vorherigen Adressknoten verschieben, der nun auf den nächsten Knoten zeigt, genau wie in der vorherigen gelöschten Methode des letzten Knotens.

C ++ - Code zum Löschen des N -ten Knotens aus der verknüpften Liste:

void deletenthPositionNode (int PositionNumber)
node *curralNode = neuer Knoten;
node *vorhernode = neuer Knoten;
currentNode = headnode;
für (int count = 1; ivorhernode = currentNode;
CurrentNode = currentNode-> Weiter;

Voreinheit-> next = currentNode-> Weiter;

C ++ - Programm zum Löschen eines N -ten Knotens aus der verknüpften Liste

#enthalten
Verwenden von Namespace STD;
Klasse LinkedListNode
öffentlich:
int info;
LinkedListNode *Zeiger;
;
int längencalculate (verknüpfte listnode* node)
int count = 0;
während (Knoten!= Null)
node = node-> pointer;
zählen ++;

Rückgabezahl;

void Insert (linkedListNode ** headnode, int info)
linkedListNode* newnode = new LinkedListNode ();
newnode-> info = info;
newnode-> pointer = *headnode;
*headnode = newnode;

void DeleteNodemethod (int count, linkedListNode ** headnode)
linkedListNode * temporarynode = * headnode;
linkedListNode* vorhernode;
int länge = längencalculate (*headnode);
if (zählen < 1 || count > Länge)
Cout << "Deletion of linked list node is not valid" << endl;
zurückkehren;

// Diese Fuktion löscht den ersten Knoten der verknüpften Liste
if (count == 1)
*headnode = (*headnode)-> pointer;
Cout << temporaryNode->die Info << " deleted the linked first node" << endl;
löschen (temporarynode);
zurückkehren;

// Dies während der Schleife aufhört, wenn sie am erreicht ist
// Ende der verlinkten Liste
while (-count)
vorhernode = temporarynode;
temporarynode = temporarynode-> pointer;

// Diese Zeile aktualisiert den Vorgängerzeiger
// mit dem N -ten verknüpften Listenknotenzeiger
VorherigesNode-> pointer = temporarynode-> pointer;
// Dieser Code löscht den n -ten Knoten aus der verknüpften Liste
Cout << temporaryNode->die Info << " deleted" << endl;;
löschen (temporarynode);

void displayLinkedList (linkedListNode* item)
Cout << "\nDisplaying LinkedList => : ";
// Dieser Zustand hört auf, wenn die LinkedList am Ende erreicht wird
während (Artikel!= Null)
Cout << item->die Info << " ";
item = item-> pointer;

Cout << endl;

int main ()
linkedListNode* headnode = null;
Insert (& Headnode, 29);
Insert (& Headnode, 34);
Insert (& Headnode, 23);
Insert (& Headnode, 27);
Insert (& Headnode, 31);
Insert (& Headnode, 50);
DisplayLinkedList (Headnode);
Cout << "\n Deleting node number 3 = ";
deletenodemethod (3 & headnode);
Cout << "\n After delete node number 3, linked list will be =";
DisplayLinkedList (Headnode);
Cout << "\n Deleting node number 5 = ";
DeleteNoDemethod (5 & headnode);
Cout << "\n After delete node number 5, linked list will be =";
DisplayLinkedList (Headnode);
Rückkehr 0;

Ausgang:

Anzeige der LinkedList =>: 50 31 23 23 23 29
Löschen der Knoten Nummer 3 = 27 gelöscht
Nach dem Löschen der Knoten Nummer 3 ist die verknüpfte Liste = =
Anzeige der LinkedList =>: 50 31 23 34 29
Löschen der Knoten Nummer 5 = 29 gelöscht
Nach dem Löschen der Knoten Nummer 5 ist die verknüpfte Liste = =
Anzeige linkedList =>: 50 31 23 34

Abschluss:

In diesem Blog haben wir verschiedene Möglichkeiten untersucht, die verknüpften Listenkonzepte zu löschen und wie wir auch in einem C ++ - Programm codieren können. Schließlich untersuchten wir die Hauptkonzepte des Löschens des Knotens aus einer bestimmten Position. Linked List -Konzepte sind immer wichtig, da dies der Weg ist, um mit dem Gedächtnis des Betriebssystems zu spielen und im Vergleich zum Array viele Vorteile zu haben.