Programmierer verwenden verkettete Listen als linear verfahrbaren Datenstrukturen. Dies bedeutet, dass der Programmierer aus dem Anfang der Liste zu starten (das so genannte Kopf) und vorwärts durch die Liste ein Element in einer Zeit . Diese Methode der Datenspeicherung ermöglicht dem Programmierer, effizient fügen Sie Daten zu der Liste , die eine weitere vielseitige Alternative zu bestimmten anderen Datenstrukturen wie dynamische Arrays . Dieses Beispiel zeigt , wie eine einfache doppelt verketteten Liste, die Navigation der Liste können auf zwei Richtungen ( vorwärts und rückwärts) zu konstruieren. Things You
Text Editor brauchen
C /C + + Compiler oder IDE (z. B. Microsoft Visual Studio)
anzeigen Weitere Anweisungen
1

Erstellen Sie die Knoten -Struktur , dass wird als Datentyp des verknüpften Liste dienen . In dem Text-Editor , geben Sie den folgenden Code:

# include

int main {

struct ListNode { int

Daten ;

Strebe ListNode * prev ;

Strebe ListNode * next ;

};

return 0; }

" struct ListNode " Codeblock erstellt eine Vorlage für die Einzelteile, die Liste zu füllen wird . Diese Vorlage definiert eine ListNode als Verbreiter von drei Elementen: ein Datenelement ( eine ganze Zahl ) und Zeiger auf die vorherigen und nächsten Elemente in der Liste . Ein Zeiger ist eine Variable, die eine Speicheradresse enthält . Zeiger werden verwendet, um andere Datenstrukturen in tiefe Erinnerung verweisen und dynamisch Speicher zuweisen während Codeausführung .
2

Deklarieren Sie die Variablen , die die Liste Struktur zu organisieren . Fügen Sie diesen Beispiel-Code in die Textdatei :

int size ;

ListNode * Kopf ;

ListNode * Schwanz;

tail = Kopf ;

head = Schwanz;

Diese beiden Zeiger sind der Anfang und das Ende der Liste sind. Mit Hilfe dieser Pointer kann der Programmierer , wo der Anfang der Liste ist und wo das Ende ist einfach zu überprüfen, ob der aktuelle Knoten der "Kopf " oder "Schwanz" -Zeiger. Sie beziehen sich beide wieder zueinander im Falle einer leeren Liste .
3

Neues einfachen Algorithmus , um Elemente aus der Liste zu hängen . Folgen Sie diesem Beispiel-Code :

nichtig append ( int num) { struct

ListNode * Tracer = Kopf ;

struct ListNode * newNode = (struct ListNode *) malloc ( sizeof (struct ListNode ) );

newNode -> data = num ;

if ( head == NULL) {

head = newNode ;

tail = newNode ;

newNode -> prev = Kopf ;

newNode -> next = Schwanz;

} else {

while ( Tracer -> next = Schwanz ! )

{ Tracer = Tracer -> next ;}

newNode -> prev = Tracer ;

newNode -> next = Schwanz;

Tracer -> next = Knoten;

tail = Knoten;

}

size + +;

}

Dieser Code fügt einen Knoten am Ende der Liste. Es beginnt mit der Erstellung einen Zeiger auf den Kopf der Liste ( " Tracer " ) . Dann erstellt es einen Zeiger auf einen dynamisch zugewiesenen Speicherblock beiseite für eine neu erstellte ListNode ( newNode ) eingestellt und setzt die Daten von diesem Knoten zur integer " num" . Wenn der Kopf Punkte auf NULL ( also die Liste leer ist, weil der Kopf deutet auf nichts ) , dann die Code fügt der Knoten am Anfang der Liste. Ansonsten sind die " while"- Zyklen durch die Knoten in der Liste bis zur letzten Knoten . Wenn " Tracer " zeigt auf das letzte Element der Liste , die Code fügt der Knoten . Der letzte Befehl ergänzt die " Größe " integer , die Verfolgung der Elemente in der Liste
4

Neues Algorithmus zu entfernen und Artikel aus dem Ende der Liste : .

Leere removeNode () {

if ( tail = Kopf! ) { struct

ListNode * end = Schwanz;

tail = Schwanz -> prev ;
< p> kostenlos ( Ende );

Größe - ;

} }

Dieser Code erstellt einen Zeiger ( " Ende " ) bis zum letzten Element der Liste (die gleichen Element "Schwanz" zeigt) . Dann wird Schwanz gesetzt, um das Element sofort darauf vor dem letzten Element (der Knoten , auf den der " zurück "-Zeiger des letzten Elements ) . Schließlich wird der Speicher nach letztem Knoten , bezeichnet durch "end" , verwendet für die weitere Verwendung freigegeben.