C Academy · Leçon

Listes simplement chaînées

Nœuds et pointeurs

Listes simplement chaînées est une leçon C Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C Academy comprend 4 leçons au total.

Qu’est-ce qu’une liste chaînée ?

Une liste chaînée est une suite de petites structures appelées nœuds. Chaque nœud contient une valeur et un pointeur vers le nœud suivant.

Contrairement aux tableaux, les éléments n’ont pas besoin d’être contigus en mémoire, et la liste peut facilement s’agrandir ou rétrécir.

#include <stdio.h>

struct Node {
    int value;
    struct Node *next;
};

int main(void) {
    printf("A node holds a value and a next pointer\n");
    return 0;
}

Définir un nœud

La structure du nœud contient les données ainsi qu’un struct Node *next pointant vers le nœud suivant.

Le type du pointeur fait référence à la même structure, ce qui permet de relier les éléments de la chaîne.

#include <stdio.h>

struct Node {
    int value;
    struct Node *next;
};

int main(void) {
    struct Node n;
    n.value = 42;
    n.next = NULL;
    printf("value=%d, next is NULL: %d\n", n.value, n.next == NULL);
    return 0;
}

Le pointeur de tête

Une liste est identifiée par un unique pointeur vers son premier nœud, appelé la tête.

Une liste vide est simplement une tête égale à NULL.

#include <stdio.h>

struct Node { int value; struct Node *next; };

int main(void) {
    struct Node *head = NULL;
    printf("List is empty: %d\n", head == NULL);
    return 0;
}

Allouer un nœud

Les nœuds sont généralement créés sur le tas avec malloc afin de survivre à la fonction qui les crée.

Vérifiez toujours la valeur renvoyée et pensez à libérer les nœuds ultérieurement.

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

struct Node { int value; struct Node *next; };

int main(void) {
    struct Node *n = malloc(sizeof(struct Node));
    n->value = 7;
    n->next = NULL;
    printf("%d\n", n->value);
    free(n);
    return 0;
}

Opérateur flèche

Lorsque vous disposez d’un pointeur vers une structure, utilisez -> pour accéder à ses membres. n->value signifie la même chose que (*n).value.

Vous utiliserez constamment l’opérateur flèche avec les listes chaînées.

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

struct Node { int value; struct Node *next; };

int main(void) {
    struct Node *n = malloc(sizeof(struct Node));
    n->value = 99;
    printf("%d\n", n->value);
    free(n);
    return 0;
}

Relier deux nœuds

Pour relier des nœuds, faites pointer le next du premier vers le second. Le next du dernier nœud reste égal à NULL pour marquer la fin.

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

struct Node { int value; struct Node *next; };

int main(void) {
    struct Node *a = malloc(sizeof(struct Node));
    struct Node *b = malloc(sizeof(struct Node));
    a->value = 1; a->next = b;
    b->value = 2; b->next = NULL;
    printf("%d -> %d\n", a->value, a->next->value);
    free(a); free(b);
    return 0;
}

Une fonction auxiliaire pour créer des nœuds

Les allocations répétées sont fastidieuses ; encapsulez-les donc dans une fonction auxiliaire qui alloue, initialise et renvoie un nouveau nœud.

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

struct Node { int value; struct Node *next; };

struct Node *make(int v) {
    struct Node *n = malloc(sizeof(struct Node));
    n->value = v;
    n->next = NULL;
    return n;
}

int main(void) {
    struct Node *n = make(5);
    printf("%d\n", n->value);
    free(n);
    return 0;
}

Construire une petite liste

À l’aide de la fonction auxiliaire, construisez une liste de trois nœuds 1 -> 2 -> 3 en reliant les pointeurs next.

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

struct Node { int value; struct Node *next; };
struct Node *make(int v){struct Node*n=malloc(sizeof*n);n->value=v;n->next=NULL;return n;}

int main(void) {
    struct Node *head = make(1);
    head->next = make(2);
    head->next->next = make(3);
    printf("%d %d %d\n", head->value, head->next->value, head->next->next->value);
    return 0;
}

Afficher la liste

Pour afficher chaque valeur, commencez par la tête et suivez les pointeurs next jusqu’à atteindre NULL.

Ce schéma de parcours constitue la base de presque toutes les opérations sur les listes.

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

struct Node { int value; struct Node *next; };
struct Node *make(int v){struct Node*n=malloc(sizeof*n);n->value=v;n->next=NULL;return n;}

int main(void) {
    struct Node *head = make(1);
    head->next = make(2);
    for (struct Node *p = head; p; p = p->next)
        printf("%d ", p->value);
    printf("\n");
    return 0;
}

Tableaux et listes chaînées

Les tableaux offrent un accès rapide par index, mais leur taille est fixe. Les listes chaînées facilitent l’insertion et la suppression, mais l’accès est plus lent, car vous devez parcourir la liste pour atteindre un élément.

Faites votre choix en fonction des opérations qui dominent dans votre programme.

#include <stdio.h>

int main(void) {
    printf("Array: O(1) index, costly resize\n");
    printf("List:  O(n) index, cheap insert/delete\n");
    return 0;
}

Libérer toute la liste

Chaque nœud alloué dynamiquement doit être libéré. Parcourez la liste, mais enregistrez le pointeur suivant avant de libérer chaque nœud, sinon vous perdez le reste de la chaîne.

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

struct Node { int value; struct Node *next; };
struct Node *make(int v){struct Node*n=malloc(sizeof*n);n->value=v;n->next=NULL;return n;}

int main(void) {
    struct Node *head = make(1);
    head->next = make(2);
    struct Node *p = head;
    while (p) {
        struct Node *nxt = p->next;
        free(p);
        p = nxt;
    }
    printf("freed all nodes\n");
    return 0;
}

Vérification rapide

Vérifiez votre compréhension de la structure des listes chaînées.

Récapitulatif

Vous avez appris les bases des listes simplement chaînées :

Un nœud contient une valeur et un pointeur next ; la tête pointe vers le premier nœud.
Allouez les nœuds avec malloc et accédez aux membres avec ->.
Le next du dernier nœud vaut NULL ; parcourez la liste en suivant les pointeurs.
Libérez toujours chaque nœud avec free, en enregistrant next avant la libération.

Questions Fréquemment Posées

La leçon « Listes simplement chaînées » est-elle gratuite ?

Oui — le texte complet de « Listes simplement chaînées » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C Academy, passe à CoddyKit PRO. Le cours C Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Listes simplement chaînées » ?

Nœuds et pointeurs Tu pratiques C Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C Academy ?

Aucune expérience préalable n'est requise. C Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Listes simplement chaînées » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C Academy ?

Oui. Chaque leçon C Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à C Academy