Généralités sur les listes chainées
Lorsque vous créez un tableau, les éléments de celui-ci sont placés de façon contiguë en mémoire.
Une liste chaînée est différente dans le sens où les éléments de votre liste sont répartis dans la mémoire et
reliés entre eux par des pointeurs. Vous pouvez ajouter et enlever des éléments d'une liste chaînée à n'importe
quel endroit, à n'importe quel instant.
Nous allons essayer de voir ceci plus en détail sur ces schémas :
Vous avez sur ce schéma la représentation que l'on pourrait faire d'un tableau et d'une liste chaînée. Chacune
de ces représentations possède ses avantages et inconvénients.
Dans un tableau, la taille est connue, l'adresse du premier élément aussi. Lorsque vous déclarez un
tableau, la variable contiendra l'adresse du premier élément de votre tableau.
Comme le stockage est contigu, et la taille de chacun des éléments connue, il est possible d'atteindre
directement la case i d'un tableau.
Pour déclarer un tableau, il faut connaître sa taille.
Dans une liste chaînée, la taille est inconnue au départ, la liste peut avoir autant d'éléments que votre
mémoire le permet.
Il est en revanche impossible d'accéder directement à l'élément i de la liste chainée.
Pour ce faire, il vous faudra traverser les i-1 éléments précédents de la liste.
Pour déclarer une liste chaînée, il suffit de créer le pointeur qui va pointer sur le premier élément de
votre liste chaînée, aucune taille n'est donc à spécifier.
Il est possible d'ajouter, de supprimer, d'intervertir des éléments d'une liste chaînée en manipulant
simplement leurs pointeurs.
Chaque élément d'une liste chaînée est composé de deux parties :
la valeur que vous voulez stocker,
l'adresse de l'élément suivant, s'il existe.
S'il n'y a plus d'élément suivant, alors l'adresse sera NULL, et désignera le bout de la chaîne.
Les deux schémas suivants expliquent comment se passent l'ajout et la suppression d'un élément d'une liste
chaînée. Remarquez le symbole en bout de chaîne qui signifie que l'adresse de l'élément suivant ne pointe sur
rien, c'est-à-dire sur NULL.
Déclaration en C d'une liste chainée
Vous pouvez créer des listes chaînées de n'importe quel type d'éléments : entiers, caractères, structures,
tableaux, voir même d'autres listes chaînées... Voici la déclaration d'une liste simplement chaînée d'entiers :
1 #include <stdlib.h>
2
3 typedef struct element Telement;
4 struct element
5 {
6 int valeur;
7 struct element *suivant;
8 };
9
10 typedef Telement* Tliste;
On crée le type Telement qui est une structure contenant un entier (val) et un pointeur sur élément (suivant),
qui contiendra l'adresse de l'élément suivant. Ensuite, il nous faut créer le type Tliste qui est un pointeur sur le
type Telement.
Lorsque nous déclarons la liste chaînée, nous devrons déclarer un pointeur sur Telement, l'initialiser à NULL,
pour pouvoir ensuite allouer le premier élément. Il faut inclure stdlib.h afin de pouvoir utiliser la macro NULL.
Voilà comment déclarer une liste chaînée (vide pour l'instant) :
1 #include <stdlib.h>
2
3 typedef struct element Telement;
4 struct element
5 {
6 int valeur;
7 struct element *suivant;
8 };
9
10 typedef element* Tliste;
11
12
13
14 int main()
15 {
16 /* Déclarons 3 listes chaînées de façons différentes
17 mais équivalentes */
18 Tliste ma_liste1 = NULL;
19 Telement *ma_liste2 = NULL;
20 struct element *ma_liste3 = NULL;
21
22
23 return 0;
}
Manipuler les listes chainées
Ajouter un élément
Lorsque nous voulons ajouter un élément dans une liste chaînée, il faut savoir où l'insérer. Les deux ajouts
génériques des listes chaînées sont les ajouts en tête, et les ajouts en fin de liste.
Ajouter en tête
Lors d'un ajout en tête, nous allons créer un élément, lui assigner la valeur que l'on veut ajouter, puis pour
terminer, raccorder cet élément à la liste passée en paramètre. Lors d'un ajout en tête, on devra donc assigner
à suivant l'adresse du premier élément de la liste passé en paramètre.
1 Tliste ajouterEnTete(Tliste liste, int X)
2 {
3 /* On crée un nouvel élément */
4 Telement* nouvelElement = malloc(sizeof(Telement));
5
6 /* On assigne la valeur au nouvel élément */
7 nouvelElement->valeur = X;
8
9 /* On assigne l'adresse de l'élément suivant
10 au nouvel élément */
11 nouvelElement->suivant = liste;
12
13 /* Le nouvel élement devient le premier élément de la liste */
14 liste = nouvelElement;
/* On retourne la nouvelle liste,
i.e. le pointeur sur le premier élément */
return liste;
}
Ajouter en fin de liste
Cette fois-ci, c'est un peu plus compliqué. Il nous faut tout d'abord créer un nouvel élément, lui assigner sa
valeur, et mettre l'adresse de l'élément suivant à NULL. En effet, comme cet élément va terminer la liste nous
devons signaler qu'il n'y a plus d'élément suivant. Ensuite, il faut faire pointer le dernier élément de liste
originale sur le nouvel élément que nous venons de créer. Pour ce faire, il faut créer un pointeur temporaire
sur Telement qui va se déplacer d'élément en élément, et regarder si cet élément est le dernier de la liste. Un
élément sera forcément le dernier de la liste si NULL est assigné à son champ suivant.
1 Tliste ajouterEnFin(Tliste liste, int X)
2 {
3 /* On crée un nouvel élément */
4 Telement* nouvelElement = malloc(sizeof(Telement));
5
6 /* On assigne la valeur au nouvel élément */
7 nouvelElement->valeur = X;
8
9 /* On ajoute en fin, donc aucun élément ne va suivre */
10 nouvelElement->suivant = NULL;
11
12 if(liste == NULL)
13 {
14 /* Si la liste est videé il suffit de renvoyer
15 l'élément créé */
16 return nouvelElement;
17 }
18 else
19 {
20 /* Sinon, on parcourt la liste à l'aide d'un pointeur
21 temporaire et on indique que le dernier élément de
22 la liste est relié au nouvel élément */
23
24 Telement* temp=liste;
25 while(temp->suivant != NULL)
26 {
27 temp = temp->suivant;
28 }
29 temp->suivant = nouvelElement;
return liste;
}
}
Comme vous pouvez le constater, nous nous déplaçons le long de la liste chaînée grâce au pointeur temp. Si
l'élément pointé par temp n'est pas le dernier (temp->suivant != NULL), on avance d'un cran (temp = temp-
>suivant) en assignant à temp l'adresse de l'élément suivant. Une fois que l'on est au dernier élément, il ne
reste plus qu'à le relier au nouvel élément.
