Erklärung des Codes (verknüpfte Liste C)

Dies ist nicht mein code. Ich nahm diesen code aus dieser website:

http://www.macs.hw.ac.uk/~rjp/Coursewww/Cwww/linklist.html

Ich bin mit Referenz-material, wie zum erstellen einer verknüpften Liste. Ich bin ein wenig verwirrt, was Los ist. Kann mir jemand bitte erklären, was Los ist. Ich werde mark, was ist verwirrend mich mit 1-5.

#include<stdlib.h>
#include<stdio.h>

struct list_el {
   int val;
   struct list_el * next;
};

typedef struct list_el item;

void main() {
   item * curr, * head;
   int i;

   head = NULL;   //1

   for(i=1;i<=10;i++) {
      curr = (item *)malloc(sizeof(item));
      curr->val = i;
      curr->next  = head; //2
      head = curr; //3
   }

   curr = head; //4

   while(curr) {  //5
      printf("%d\n", curr->val);
      curr = curr->next ;
   }

head = NULL → warum ist Leiter wird auf NULL gesetzt? Ich weiß, dass man eigentlich (ich mache es aus Gewohnheit), aber ich weiß wirklich nicht, warum.
curr->next = head → ich habe nie wirklich verstanden, diese als gut. Vielleicht habe ich meine definition von "Kopf" ist falsch, aber regelmäßig in einer verknüpften Liste, ist es der Start-Knoten oder der Letzte Knoten in der Liste? Ich habe immer vermutet, es sei der Startknoten, aber in dieser Linie sieht es aus wie es ist der Letzte Knoten.
Kopf = curr → Warum setzen wir es gleich curr?
curr = head > und dann die Einstellung curr = head, nachdem die Schleife fertig ist.
while(curr) → Nur um sicher zu gehen, das ist die Traversierung durch die Liste, und es ist äquivalent zu while(curr != NULL) right?

Die Liste ist gebaut, durch das anbringen von Knoten, die auf dem front-end und die Anpassung der Leiter auf den neuen Knoten.
Dieser code erstellt eine verlinkte Liste, so könnte es helfen haben ein klares Verständnis von dem, was eine verkettete Liste ist: en.wikipedia.org/wiki/Linked_list

InformationsquelleAutor juice | 2013-03-15

c head linked-list

18

#1: head = NULL

Initialisierung der Zeiger. Es ist in der Regel empfohlen zur Initialisierung der Zeiger auf NULL ist, entweder (1) bei der Deklaration oder (2) unverzüglich nach der Erklärung. Wenn der Programmierer versehentlich zu dereferenzieren, die nicht initialisierte Zeiger, garbage Werte werden zurückgegeben. Häufig Zeiten, das ist extrem schwer zu Debuggen, wenn Ihre statische Analyse und compiler werden nicht angezeigt, warn-oder Fehlermeldungen für nicht initialisierte Zeiger.

Weitere Informationen entnehmen Sie bitte Steve McConnell Code Complete: A Practical Handbook of Software Construction oder Wikipedia-Seite über Defensiv Programmieren.

#2: curr->next = head

Aufbau der linked-Liste. Die curr Knoten "verbunden" um die zuvor erstellte Knoten in der Sequenz.

#3: head = curr

Aktualisierung der Kopf-Zeiger. Die head Zeiger wird aktualisiert, und zeigen Sie die zuletzt malloced Knoten.

Nachstehenden Abbildungen visualisieren die Schritte #2 und #3:

#4: curr = head

Re-Initialisierung der Zeiger. Dieser Schritt ist ähnlich zu Schritt #2:curr->next = head. Durch die Einstellung curr Knoten head, curr bekommt "bereit" für linked-list traversal in der while Schleife. Analog sprechen, es ist wie bei der Initialisierung der Iteration variable auf 0 am Anfang der Schleife (d.h. i = 0). Visualisieren Sie diesen Schritt, entnehmen Sie bitte der untenstehenden Abbildungen zeigen, vor/nach dieser Anweisung ausgeführt wird:

#5: while(curr)

Das Durchlaufen der Liste.
Da curr verweist auf den ersten Knoten (Schritt #4), das while Schleife durchläuft die Liste, bis curr->next NULL zurück. In einer weniger abstrakten form, die wir umschreiben können, diese Aussage als while(curr != NULL).

Eine wirklich ausgezeichnete Antwort. Sehr erklärend und einfach zu verstehen. Kämpfen mit verknüpften Listen atm und das es aussortiert. Danke.

InformationsquelleAutor
5
1. Kopf, deutete auf den Kopf der Liste. Da die Liste derzeit noch leer, es ist auf null gesetzt
2. Wenn Sie einen Knoten hinzufügen, um der Liste, legen Sie die "next" - Zeiger auf die aktuelle Spitze der Liste. Die stellt den neuen Knoten an der Spitze der Liste.
3. "Kopf" "curr"", um die neuen Knoten der Spitze der Liste.
4. Nach der Schleife ist vorbei, Sie sind wieder mit dem "curr" - variable zum Durchlaufen der Liste.
5. Die Sie gehen Sie durch die Liste der Einstellung "curr" zu jedem Knoten in drehen Sie, bis Sie Weg gehen, der unten in der Liste (wo curr->next ist null)
InformationsquelleAutor Paul Tomblin
3

(1). Sie müssen, um es zu etwas, und NULL ist eine Art zu sagen: es ist nicht das zeigen auf etwas. In der Regel NULL ist die gleiche wie 0. In einigen Sprachen, die Sie nicht brauchen zum initialisieren der Variablen, weil es automatisch setzen Sie ihn auf null. Aber C macht das nicht, so haben Sie es selbst zu tun.

(2). head verweist auf den ersten Knoten der Liste. Auf den ersten, es ist NULL, was bedeutet, dass die Liste leer ist und somit head nicht zeigen auf etwas. cur ist ein neuer Knoten, der will, eingefügt in die Liste. curr->next will, zeigen Sie auf den ersten Knoten der Liste, so das ist, warum curr->next eingestellt ist head.

(3). An dieser Stelle head ist nicht mehr auf den ersten Knoten. Das erste mal durch die Schleife sieht es so aus:
```
curr-->node1-->NULL 
Kopf--^ 
```
Aber im Allgemeinen würde es so Aussehen
```
curr-->knoten3-->node2-->node1-->NULL 
Kopf--^ 
```
Wir müssen also die update - head auf den ersten Knoten. Da curr verweist auf den neu erstellten Knoten, die an der front, setzen wir einfach head auf demselben Knoten wie curr.

(4). Der erste Teil des Programms ist fertig. curr ist nicht mehr erforderlich, weil es war verwendet, um zu verfolgen, welche neuen Knoten, die wir erstellt haben. Es wurde eine temporäre variable. Diese Linie curr = head heißt, wir gehen zu initialisieren curr an den Anfang der Liste. Wir habe verwendet eine weitere variable, um Sie lesbarer zu machen, aber Sie in der Regel sehen die Wiederverwendung von temporären Variablen.

(5). Recht. Wahrscheinlich sehen Sie NULL definiert als (void*)0, so dass es das gleiche ist wie 0. Sie werden wahrscheinlich nie sehen anderen anderen Wert als 0, außer für die wirklich alten Maschinen aus den 60er oder 70er Jahren. So logisch, es ist das äquivalent zu:
while (curr != 0) das ist das gleiche wie while (curr).

InformationsquelleAutor ckim
2

1. Kopf = NULL → warum ist Leiter wird auf NULL gesetzt?

Es ist gute Praxis, initialisieren Sie Ihre Variablen. Auf einigen Systemen deklarierte Variablen haben, was passiert im Speicher, wenn der Adressraum packte.

2. curr->next = head → ich habe nie wirklich verstanden, diese als gut. Vielleicht habe ich meine definition von "Kopf" ist falsch, aber regelmäßig in einer verknüpften Liste, ist es der Start-Knoten oder der Letzte Knoten in der Liste? Ich habe immer vermutet, es sei der Startknoten, aber in dieser Linie sieht es aus wie es ist der Letzte Knoten.

Ja, der Kopf ist der Startknoten.

3. Kopf = curr → Warum setzen wir es gleich curr?

Dieser loop hier fügt neue Knoten als der Kopf. Wie ein stack. Andere Möglichkeiten, es zu tun hinzufügen von neuen Knoten in den Schwanz. Beide Wege sind immer noch "verknüpfte Listen".

4. curr = head > und dann die Einstellung curr = head, nachdem die Schleife fertig ist.

curr benimmt sich wie ein index, ein variable, so dass Sie nicht distrupt die Daten-Struktur. Er ist ein Reset, nachdem er getan hat. "Das Zurückspulen des Bandes" wenn man so will.

5. while(curr) → Nur um sicher zu gehen, das ist die Traversierung durch die Liste, und es ist äquivalent zu while(curr != NULL) right?

Ja, das ist eine dieser stillschweigenden Dinge, die Sie finden in C. Alles andere ganz von selbst in eine while-Schleife wird implizit while(whatnot != 0) und null == 0.

Ok, das ist, wo ich war immer verwirrt.. en.wikipedia.org/wiki/Linked_list In die einfach verkettete Liste in Abschnitt.. die box mit dem 'x' im ist es der Kopf oder der Schwanz?
Das Kästchen mit dem " X " im inneren ist die NULL-Adresse. Das Letzte element verweist, um zu zeigen 'Hey, ich bin der Letzte, es ist niemand hinter mir'. Eine Schleife über diese Liste finden Sie unter diesem NULL-Zeiger im letzten Element, und beenden Sie die Schleife.
Ja, in diesem Beispiel #12 ist der Wert, bei dem Kopf, und die #37 ist der Wert, bei dem Schwanz.

InformationsquelleAutor Philip
2

Zuerst finden Sie die Antwort auf die Frage, warum der Kopf ist immer NULL in Verkettete Listen Kopf Ist Immer Null und Einfache Verkettete Liste C++ . Ein tutorial für Anfänger finden Sie auf einfach verknüpfte Liste in c. Die Aussage head=curr asociated der Wert des Zeigers Kopf, was war NULL auf den Wert des aktuellen Zeigers, dass der Eingang einen Wert ungleich null, werden durch die Zuweisung von Speicher. while(curr), ist eine Schleife, die so lange ausgeführt, curr Verschieden von NULL ist, wird NULL als makro zugeordnete Wert null für den Hinweis-Adresse.

InformationsquelleAutor user1929959
2

Wir starten mit nichts. Das ist es, was
```
head = NULL;
```
uns erzählt. Wir haben noch keine Liste, so dass wir nicht auf Sie zugreifen.

Wir nun in die Schleife von 1 bis 10. Wir bauen eine Liste von hinten nach vorne. LEITER NULL ist, also die "letzten" (die zuerst erstellt wird) - Punkte auf NULL:
```
curr->next  = head; //head is NULL in the first loop
```
KOPF ist nun auf das neue element:
```
head = curr;
```
Den zweiten Durchgang durch diese Schleife, Kopf speichert den Zeiger auf das Letzte erstellte Element. Die neu erstellte wird sich dann zeigen. Wir setzen dieses neue Element vor dem letzten Element.

Einstellung
```
head = curr;
```
getan werden muss, um sicherzustellen, dass der Kopf enthält die richtigen Zeiger in die nächste Schleife. Es heißt Kopf, denn es speichert immer den Anfang der Liste, die erstellt wurde, bis dann.

//4 ist nicht wirklich notwendig.

Die Letzte operation war vor:
```
head = curr;
```
So
```
curr = head;
```
ist sinnlos.

Und die 5. man iteriert durch die Liste. "curr" und verweist auf das erste Element (mit einer nicht-NULL-Adresse) und ist so eingestellt, curr->next in each-Schleife. Einmal curr NULL ist (das Letzte Element), die Aussage ist nicht mehr wahr.

InformationsquelleAutor flyingOwl
0

In der 4. problem,ich glaube nicht, dass curr=head notwendig ist.Denn wenn die Schleife vorbei ist,curr und Kopf hatte-pointer der gleiche Knoten(Knoten i=10).
Aber es ist eine gute Gewohnheit.

InformationsquelleAutor Chandler's Sexyface