Explication du code (liste chaînée C)

Ce n'est pas mon code. J'ai pris ce code sur ce site:

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

Je suis à l'aide de documents de référence sur la façon de construire une liste liée. Je suis un peu confus sur ce qui se passe. Quelqu'un peut-il m'expliquer ce qui se passe. Je vais marquer ce qui est de me confondre avec 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 ;
   }

tête = NULL → pourquoi la tête d'être mis à NULL? Je sais que vous êtes censé (je le fais d'habitude), mais je ne sais pas vraiment pourquoi.
curr->next = tête → je n'ai jamais vraiment compris. J'ai peut-être ma définition de la "tête" de mal, mais dans une liste liée, est-ce que le nœud de départ ou le dernier nœud sur la liste? J'ai toujours supposé que c'était le nœud de départ, mais dans cette ligne, on dirait que c'est le dernier nœud.
tête = curr → Pourquoi sommes-nous définir égal à curr?
curr = la tête → puis en définissant curr = la tête après la boucle est terminée.
while(curr) → Juste pour s'assurer, c'est de la traversée par le biais de la liste et il est équivalent à tout(curr != NULL) droit?

source d'informationauteur juice

c head linked-list

18

#1: head = NULL

De l'initialisation du pointeur de. C'est généralement recommandé d'initialiser le pointeur à NULL soit (1) lors de la déclaration ou (2) immédiatement après la déclaration. Si les programmeurs tort de déréférencement de pointeurs non initialisés, les ordures, les valeurs sont retournées. Le plus souvent, c'est extrêmement difficile à déboguer si votre analyseur statique et le compilateur n'affiche pas d'avertissement les messages d'erreur ou des pointeurs non initialisés.

Pour plus d'informations, veuillez vous référer à Steve McConnell le Code Complet: Un Manuel Pratique de Construction de Logiciels ou la page Wikipédia sur une Programmation Défensive.

#2: curr->next = head

La construction de la liste liée. Le curr nœud est "liée" à créé précédemment noeud dans la séquence.

#3: head = curr

Mise à jour le pointeur de têtes. Le head pointeur est mis à jour pour pointer à la dernière malloced nœud.

Ci-dessous des illustrations de visualiser les Étapes #2 et #3:

#4: curr = head

Ré-initialisation du pointeur. Cette étape est similaire à l'étape #2:curr->next = head. Par la mise en curr nœud à headcurr est "prêt" pour la liste liée traversée de la while boucle. Analogiquement parlant, c'est comme l'initialisation de la variable d'itération à 0 au début de la boucle (c'est à dire i = 0). Pour visualiser cette étape, reportez-vous aux illustrations ci-dessous montrant avant/après cette instruction est exécutée:

#5: while(curr)

Parcourant la liste.
Étant donné que curr vers le premier nœud (à partir de l'étape n ° 4), ce while boucle parcourt la liste jusqu'à ce que curr->next renvoie la valeur NULL. De moins en moins la forme de résumé, nous pouvons réécrire cette déclaration comme while(curr != NULL).
5
1. la tête vers la tête de la liste. Étant donné que la liste est vide, il est défini sur null
2. Lorsque vous ajoutez un nœud à la liste, vous définissez la "prochaine" pointeur à l'actuel chef de la liste. Le met le nouveau nœud à la tête de la liste.
3. Vous définissez la "tête" à "curr" pour rendre le nouveau nœud à la tête de la liste.
4. Après la boucle est terminée, vous êtes à la re-utilisation de la "curr" variable pour parcourir la liste.
5. Vous allez par le biais de la configuration de la liste de "curr" à chaque nœud à son tour jusqu'à ce que vous allez au bas de la liste (où curr->suivant est null)
3

(1). Vous avez besoin de quelque chose et utiliser la valeur NULL est une façon de dire qu'il n'est pas pointant vers quoi que ce soit. Habituellement, la valeur NULL est la même chose que 0. Dans certaines langues, vous n'avez pas besoin d'initialiser la variable, car il est automatiquement mis à zéro. Mais C ne fait pas que de sorte que vous avez à faire vous-même.

(2). head vers le premier nœud de la liste. Au premier abord, il est NULL, ce qui signifie que la liste est vide et donc head ne pointe sur rien. cur est un nouveau nœud qui veut être inséré dans la liste. curr->next veut point pour le premier nœud de la liste existante, de sorte que c'est pourquoi curr->next est fixé à head.

(3). À ce stade, head n'est plus pointant vers le premier nœud. La première fois dans la boucle, il ressemble à ceci:
```
curr-->node1-->NULL 
tête--^ 
```
Mais en général, il devrait ressembler à ceci
```
curr-->nœud3-->node2-->node1-->NULL 
tête--^ 
```
Nous avons donc besoin de mettre à jour head pour pointer vers le premier nœud. Depuis curr vers le nouveau noeud créé, qui est placé à l'avant, nous venons de mettre head pour pointer vers le même nœud que curr.

(4). La première partie du programme est faite. curr n'est plus nécessaire, car il était utilisé pour garder une trace de la nouvelle nœud que nous avons créé. C'était une variable temporaire. Cette ligne curr = head signifie que nous allons initialiser curr au début de la liste. Nous pourrions ai utilisé une autre variable pour le rendre plus lisible, mais en général vous voir réutilisation des variables temporaires.

(5). La droite. Vous verrez probablement NULL défini comme (void*)0donc c'est la même chose que 0. Vous aurez probablement jamais voir un autre de valeur autre que 0, sauf pour les très vieilles machines à partir des années 60 ou 70. Donc, logiquement, c'est équivalent à:
while (curr != 0) qui est le même que while (curr).
2

1. tete = NULL → pourquoi la tête d'être mis à NULL?

C'est une bonne pratique pour initialiser vos variables. Sur certains systèmes, les variables déclarées ont ce qui est arrivé à être dans la mémoire lorsque l'espace d'adressage est saisi.

2. curr->next = tête → je n'ai jamais vraiment compris. J'ai peut-être ma définition de la "tête" de mal, mais dans une liste liée, est-ce que le nœud de départ ou le dernier nœud sur la liste? J'ai toujours supposé que c'était le nœud de départ, mais dans cette ligne, on dirait que c'est le dernier nœud.

Oui, la tête est le nœud de départ.

3. tête = curr → Pourquoi sommes-nous définir égal à curr?

Cette boucle ajoute de nouveaux nœuds que la tête. Comme une pile. D'autres moyens de le faire ajouter de nouveaux nœuds sur la queue. Les deux façons sont encore des "listes".

4. curr = la tête → puis en définissant curr = la tête après la boucle est terminée.

curr est d'agir comme un indice, une variable de sorte que vous n'avez pas distrupt la structure de données. Il est de le réinitialiser après qu'il a fait. "Rembobiner la bande," si vous.

5. while(curr) → Juste pour s'assurer, c'est de la traversée par le biais de la liste et il est équivalent à tout(curr != NULL) droit?

Oui, c'est un de ces implicite des choses que vous trouvez dans C. Rien par lui-même dans une boucle while est implicitement while(whatnot != 0) et null == 0.
2

Tout d'abord, vous pouvez trouver la réponse à la question de savoir pourquoi la tête est toujours la valeur NULL dans Liste Liée Tête Est Toujours Null et Simple C++ Liste Liée. Un tutoriel pour débutant, vous pouvez trouver à seule liste liée dans c. La déclaration de la tête=curr associée à la valeur du pointeur de la tête ce qui était NULLE à la valeur du pointeur courant que le fait de recevoir une valeur différente de zéro par une allocation de mémoire. while(curr) est une boucle qui s'exécute tant curr différents de NULL, NULL comme une macro associée à la valeur zéro pour le pointage d'adresse.
2

Nous sommes à partir de rien. C'est ce que
```
head = NULL;
```
nous le dit. Nous n'avons pas de liste, de sorte que nous ne pouvons pas y accéder.

Maintenant, nous sommes en boucle de 1 à 10. Nous construisons une liste à partir de l'arrière vers l'avant. La TÊTE est NULLE, de sorte que le "dernier" (le premier créé) points à NULL:
```
curr->next  = head; //head is NULL in the first loop
```
TÊTE de est désormais fixé à ce nouvel élément:
```
head = curr;
```
La deuxième manche grâce à cette boucle, la tête stocke le pointeur de la dernière création de l'élément. La nouvelle sera alors le point. Nous avons mis ce nouvel élément devant le dernier élément.

Réglage
```
head = curr;
```
qui doit être fait pour s'assurer que la tête contient le pointeur dans la prochaine boucle. Il est appelé à la tête, car il stocke toujours le début de la liste qui a été créé jusqu'alors.

//4 n'est pas vraiment nécessaire.

De la dernière opération avant l'été:
```
head = curr;
```
Donc
```
curr = head;
```
est absurde.

Et la 5e on parcourt la liste. "curr" points sur le premier élément (avec une valeur non NULLE de l'adresse) et est fixé à curr->suivant dans chaque boucle. Une fois curr est NULL (sur le dernier élément), l'état n'est plus vrai.
0

Dans le 4ème problème,je ne pense pas que curr=head est nécessaire.Parce que quand la boucle est terminée,curr et la tête avait pointeur de la même nœud(nœud de i=10).
Mais c'est une bonne habitude.