Construction d’une Liste Linéaire Chaînée

Dans ce module, nous allons décomposer visuellement la création d’une liste chaînée, étape par étape, en utilisant des représentations graphiques pour chaque concept (Nœud, Data, Next, Head).

1. Structure d’un Nœud (The Node)

Un nœud est la brique de base. Il est divisé en deux parties (les “petits carrés”) :

1. DATA : La valeur stockée (ex: 7, 9, 12).
2. NEXT : Le pointeur vers le nœud suivant.

Représentation graphique d’un Nœud :

+--------+--------+
|  DATA  |  NEXT  |
|   7    |   ---->|  (Pointe vers...)
+--------+--------+

En C, cela correspond à :

typedef struct Node {
    int data;
    struct Node* next;
} Node;

2. Étape 1 : Création du Premier Nœud (Head)

Au départ, nous avons un pointeur head (tête) qui ne pointe vers rien (NULL). Puis nous créons notre premier nœud avec la valeur 7.

Node* head = NULL;
Node* one = malloc(sizeof(Node));
one->data = 7;
one->next = NULL;
head = one;

Visuellement :

3. Étape 2 : Ajout du Deuxième Nœud

Nous créons un deuxième nœud avec la valeur 9. Nous devons relier le champ next du premier nœud vers ce nouveau nœud.

Node* two = malloc(sizeof(Node));
two->data = 9;
two->next = NULL;

one->next = two; // Le lien se crée ici

Visuellement :

4. Étape 3 : Ajout du Troisième Nœud (Finalisation)

Nous ajoutons le dernier nœud avec la valeur 12. C’est la structure finale que vous avez vue dans l’exemple.

Node* three = malloc(sizeof(Node));
three->data = 12;
three->next = NULL;

two->next = three; // Lien entre 9 et 12

Visuellement (La Liste Complète) :

(Note : La croix verte sur le dernier nœud représente la valeur NULL, indiquant la fin de la liste)

Code Complet ©

Voici le code C complet pour générer cette liste exacte :

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

typedef struct Node {
    int data;
    struct Node* next;
} Node;

int main() {
    // 1. Initialisation des pointeurs
    Node *head;
    Node *one = NULL;
    Node *two = NULL;
    Node *three = NULL;

    // 2. Allocation de la mémoire
    one = malloc(sizeof(Node));
    two = malloc(sizeof(Node));
    three = malloc(sizeof(Node));

    // 3. Assignation des valauers
    one->data = 7;
    two->data = 9;
    three->data = 12;

    // 4. Connexion des nœuds (Chainage)
    head = one;      // Head pointe sur le premier
    one->next = two; // 7 pointe sur 9
    two->next = three; // 9 pointe sur 12
    three->next = NULL; // 12 pointe sur rien (Fin)

    // Affichage pour vérifier
    Node *temp = head;
    while(temp != NULL) {
        printf("%d -> ", temp->data);
        temp = temp->next;
    }
    printf("NULL\n");

    return 0;
}