LES LISTES CHAINEES – CONCEPTS THEORIQUES -

Listes Simples, Listes doublements Chainées, Listes Circulaires

LISTES SIMPLEMENT CHAINEES

Définition
Une liste chaînée désigne en informatique une structure de données représentant une
collection ordonnée et de taille arbitraire d'éléments de même type.

L'accès aux éléments d'une liste se fait de manière séquentielle : chaque élément permet l'accès au
suivant (contrairement au cas du tableau dans lequel l'accès se fait de manière absolue, par
adressage direct de chaque cellule dudit tableau).
Soit la liste composée de trois éléments ayant respectivement les valeurs : 12, 99 et 37.
Schématiquement, elle représentée de la manière suivante :

Comme on le voit sur le schéma ci-contre, deux informations composent chaque élément de la
liste :
- la valeur associée à l'élément (ou donnée d'exploitation),
- un pointeur vers l'élément suivant (ou successeur).
Comme un seul autre élément de la liste est pointé, l'accès se fait uniquement dans un sens ; une
telle liste est appelée Liste Simplement Chainée (LSC).
Principe
Le principe de la liste chaînée est que chaque élément possède, en plus de la donnée, des pointeurs
vers les éléments qui lui sont logiquement adjacents dans la liste. De ce fait, l'usage d'une liste est
préconisé pour des raisons de rapidité de traitement, lorsque les insertions et suppressions d'élément
en tout point sont relativement plus fréquentes que les accès simples.
En effet, une insertion ou une suppression se font en temps constant car elles ne demandent au
maximum que deux accès en écriture. En revanche, l'accès à un élément aléatoirement positionné
nécessite le parcours de chaque élément qui sépare l'index de l'élément choisi. Il est donc préférable
d'accéder aux éléments séquentiellement.

Représentation Algorithmique d’une LSC

Type Liste = @Element
Element = Enregistrement
Info : entier
Suiv : Liste
Fin
Variable P, L : Liste
Remarque :
Un élément d’une liste est placé dans une cellule comportant deux zones : une zone contenant
l’information (Info) et une autre qui indique l’adresse de l’élément suivant de la liste (Suiv).

Algorithmes de Création et de parcours d’une LSC

On rappelle qu’une liste simplement chaînée est constituée d'un ensemble de cellules chaînées entre
elles. C'est l'adresse de la première de ces cellules qui détermine la liste. Cette adresse doit se
trouver dans une variable que nous appellerons souvent "Tête". La valeur de cette variable doit
reste toujours à la disposition du programme (un traitement nécessite généralement le placement en
début de liste).

1
On rappelle également qu’à la fin du chapitre précédent, nous avons implémenté un tableau en
utilisant les pointeurs. En fait, nous avons créé une liste très particulière car c’est une liste dont les
éléments sont connus à l’avance.
D’autre part, nous avons remarqué que la création s’est fait dans le sens inverse ; nous avons alors
repris l’algorithme pour utiliser la structure Pour dans le sens décroissant.
Maintenant, si nous reprenons l’exercice qui consiste à créer une liste comportant les moyennes
supérieures ou égales à 10, issues du fichier FEtudiant dont la structure est composée de : Cin,
Nom, Prénom, Classe et Moyenne. L’algorithme sera alors le suivant :

Algorithme List_Moy
Début
Assign (FEtudiant, ‘C:\Fetudiant.Dat’)
Ouvrir (FEtudiant, Lecture)
TNIL (* Liste au départ à vide *)
Tant que Non Fin (FEtudiant) Faire
Lire (FEtudiant, Etud)
Si (Etud.Moy >= 10) Alors
Allouer(P)
P@.Info  Etud.Moy
P@.Suiv T
TP
Fin Si
Fin Tant que
Fermer(FEtudiant)
Fin

Commentaire : Nous avons créé une liste où la politique de placement est de type : le dernier créé
sera le premier de la liste (LIFO).

Activité : Ecrire une procédure qui permet créer une chaine de caractère en utilisant une liste de
caractères ; la chaine sera entrée à partir du clavier caractère par caractère.
Type
Liste = @Element
Element = Enregistrement
Info : Caractère
Suiv : Element
Fin

Procédure Chaine_Liste (RES T : Liste)

Variable c : caractère
Début
TNIL (* Liste au départ à vide *)
Tant que Non Fin (Saisie) Faire
Lire (c)
Allouer(P)
P@.Info  c
P@.Suiv T
TP
Fin Si
Fin Tant que
Fin

2
Commentaire : l’exécution de cet algorithme nous donnera une chaine mais dans le sens contraire ;
on peut utiliser cette procédure si jamais, on nous demande d’inverser une chaine. Dans ce cas, il
suffit de changer le mode de passage de T (il devient de type DONRES) ;

La question qu’on se pose est la suivante : Comment obtient-t-on une chaine dans l’ordre naturel de
la saisie ? On doit alors utiliser l’algorithme de création de liste suivant :

Procédure Créer_Liste (RES T : Liste)

Début
(* on doit créer la tête de la liste pour qu’on puisse mémoriser son adresse *)
Allouer(T)
Lire(T@.Info)
T@.Suiv NIL
QT (* on est sûr que l’adresse de T ne sera pas écrasée *)
Tant que Non Fin (Saisie) Faire
Allouer(P)
Lire(P@.Info)
P@.Suiv NIL
Q@.Suiv P
Fin Tant que
Fin
Commentaires
(i) Avec une telle procédure, on est sûr de respecter l’ordre naturel de la saisie.
(ii) On peut optimiser cette procédure (P@.Suiv  NIL peut être enlevée et remplacer par
Q@.Suiv  NIL après Fin Tant que) ; ce qui nous donne la procédure suivante :

Procédure Créer_Liste_Optimal (Res T : Liste)

Début
(* on doit créer la tête de la liste pour qu’on puisse mémoriser son adresse *)
Allouer(T)
Lire(T@.Info)
T@.Suiv NIL
QT (* on est sûr que l’adresse de T ne sera pas écrasée *)
Tant que Non Fin (Saisie) Faire
Allouer(P)
Lire(P@.Info)
Q@.Suiv P QP
Fin Tant que
Q@.Suiv NIL
Fin
Le schéma ci-dessous présente une simulation de cet algorithme pour créer une liste T comportant
les éléments : 3, -2, 5 et 0.

3
 T

Q T

Q T P

3 -2

Q T P

3 -2

Q T P Q

3 -2

Q T P Q

3 -2

Q T P Q P

3 -2 5

Q T P Q P

3 -2 5

Q T P Q P

3 -2 5

Q T P Q P Q

3 -2 5

Q T P Q P Q P

3 -2 5 0

Q T P Q P Q P

3 -2 5 0 Fin De Saisie !!

Q T P Q P Q P Q

3 -2 5 0
4
Parcours d’une liste
Généralement, tout traitement sur une liste doit être accompagné d’un parcours dont l’algorithme
est le suivant :

Procédure Parcours_Liste (Don T : Liste)

Début
QT (* pour ne pas écraser l’adresse du début de la liste *)
Tant que (Q@.Suiv <> NIL) Faire
Q  Q@.Suiv
Fin Tant que
Fin

Algorithmes d’insertion dans une LSC

a-) Insertion en tête de liste :

Début
Allouer (P)
Lire (P@.val)
P@.suiv  T
TP
Fin
T

3 -2 5 0

P T T

9 3 -2 5 0

b-) Insertion en fin de liste :

Début
PT
Répéter P  P@.suiv Jusqu’à (P@.suiv = Nil)
Allouer (Q) Lire (Q@.val)
Q@.suiv  Nil
P@ .suiv  Q
Fin

5
 T

3 -2 5 0

P T

3 -2 5 0

P T P

3 -2 5 0

P T P P

3 -2 5 0

P T P P P
P@.suiv = NIL !!
3 -2 5 0 !!

13

T P Q

3 -2 5 0 13

c-) Insertion en milieu de liste : (Après une valeur V) On suppose V=5

Début
PT
Répéter P  P@.suiv Jusqu’à (P@.val = V)
Allouer (Q)
Lire (Q@.val)
Q@.suiv  P@.suiv
P@ .suiv  Q
Fin

6
 T

3 -2 5 0

P T

3 -2 5 0

P T P

3 -2 5 0

P T P P

3 -2 5 0 P@.val=V(5) !!
!!
Q

13

T P P

3 -2 5 0
Q@.suiv
Q 13
P@.suiv
P@.suiv
Q

T P Q

3 -2 5 13 0

Algorithmes de Suppression dans une LSC

a-) Suppression en début de liste :

Début
P T
T  T@.suiv
Libérer (P)
Fin

P T

3 -2 5 0

P T T

9 3 -2 5 0

P T T

9 3 -2 5 0

7
b-) Suppression en fin de liste :

Début
PT
Répéter
QP PP@.suiv Jusqu’à (P@.suiv = NIL)
Libérer(P)
Q@.suiv  NIL
Fin

3 -2 5 0

QP T

3 -2 5 0

P Q T P

3 -2 5 0

P Q T P Q P

3 -2 5 0

P QT P Q P Q P
P@.suiv = NIL !!
3 -2 5 0 !!

P QT P Q P Q P

3 -2 5 0

c-) Suppression au milieu de liste : (Après une valeur V) On suppose V= -2

Début
PT
Répéter P  P@.suiv Jusqu’à (P@.val = V)
Q  P@.suiv
P@ .suiv  Q@.suiv
Libérer (Q)
Fin

8
 T

3 -2 5 0

P T

3 -2 5 0

P T P
P@.val=V(2) !!
3 -2 5 0 !!

P T P Q
Q P@.suiv
3 -2 5 0
P@.suiv Q@.suiv
P T P Q

3 -2 5 0

9
LES LISTES DOUBLEMENT CHAINEES (LDC)

Définition
Une LDC est une structure de données permettant de regrouper une suite d’éléments de même type
et dont chacun possède deux liens : un lien pour accéder à l’élément suivant et un lien pour atteindre
l’élément précédent.

Représentation d’une LDC

TYPE
LDC = @Element
Element = Enregistrement
Info : Typeinfo
Suiv : LDC
Prec : LDC
Fin

Algorithme de Création d’une LDC

Début
| Allouer (T)
| Lire (T@.val)
| T@.suiv Nil
| T@.prec Nil
| Q T
| Tant Que (Non (Fin_saisie)) Faire
| | Allouer (P)
| | Lire(P@.val)
| | Q@.suiv P
| | P@.prec Q
| | Q P
| Fin Tant Que
| Q@.suiv Nil

Fin
T

Q T

Q T P

3 -2

Q T P

10
 3 -2

Q T P Q

3 -2

Q T P Q

3 -2

Q T P Q P

3 -2 5

Q T P Q P

3 -2 5

Q T P Q P

3 -2 5

Q T P Q P Q

3 -2 5

Q T P Q P Q P

3 -2 5 0

Q T P Q P Q P

3 -2 5 0 Fin De Saisie !!

Q T P Q P Q P Q

3 -2 5 0

Algorithmes d’Insertion dans une LDC

a-) Insertion en tête de liste :

Début
| Allouer (P)
| Lire (P@.val)
| P@.suiv T
| T@.prec P
| P@.prec Nil
| T P
Fin

11
 T

3 -2 5 0

P T T

9 3 -2 5 0

b-) Insertion en fin de liste :

Début
| P T
| Répéter
| | P P@.suiv
| Jusqu’à (P@.suiv = Nil)
| Allouer (Q)
| Lire (Q@.val)
| Q@.suiv Nil
| P@ .suiv Q
| Q@.prec P
Fin

3 -2 5 0

P T

3 -2 5 0

P T P

3 -2 5 0

P T P P

3 -2 5 0

P T P P P
P@.suiv = NIL !!
12 !!
 3 -2 5 0

13

T P Q

3 -2 5 0 13

c-) Insertion en milieu de liste : (Après une valeur V) On suppose V=5

Début
| P T
| Répéter P  P@.suiv Jusqu’à (P@.val = V)
| Allouer (Q)
| Lire (Q@.val)
| Q@.suiv P@.suiv
| P@ .suiv Q
| Q@.prec P
| (Q@.suiv) @.perc Q
Fin

3 -2 5 0

P T

3 -2 5 0

P T P

3 -2 5 0

P T P P

3 -2 5 0 P@.val=V(5) !!
!!
Q

13

T P P

3 -2 5 0

Q 13
Q@.prec P (Q@.suiv)@.prec Q

13
 T P Q

3 -2 5 13 0

Algorithmes de suppression dans une LDC

a-) Suppression en début de liste :

Début
| P T
| T T@.suiv
| Libérer (P)
| T@.prec Nil
Fin

P T

3 -2 5 0

P T T

9 3 -2 5 0

P T T

9 3 -2 5 0

b-) Suppression en fin de liste :

Début
| P T
| Répéter
| | Q P
| | P P@.suiv
| Jusqu’à (P@.suiv = Nil)
| Libérer (P)
| Q@.suiv Nil
Fin

3 -2 5 0

14
 QP T

3 -2 5 0

P Q T P

3 -2 5 0

P Q T P Q P

3 -2 5 0

P QT P Q P Q P
P@.suiv = NIL !!
3 -2 5 0 !!

P QT P Q P Q P

3 -2 5 0

c-) Suppression au milieu de liste : (Après une valeur V) On suppose V= - 2

Début
| P T
| Répéter PP@.suiv Jusqu’à (P@.val = V)
| Q P@.suiv
| (Q@.suiv)@.prec P
| P@ .suiv Q@.suiv
| Libérer (Q)
Fin
T

3 -2 5 0

P T

3 -2 5 0

P T P
P@.val=V(2) !!
3 -2 5 0 !!

P T P Q

3 -2 5 0 Q P@.suiv
P@.suiv Q@.suiv
P T P Q (Q@.suiv)@.prec
P
3 -2 5 0

15
APPLICATION SUR LES LISTES : LISTE CIRCULAIRE

Définition
Le cycle est la propriété que présente une liste chaînée de former une boucle (ou chaîne fermée). La
notion de début de chaîne ou de fin de chaîne disparaît. Une liste cyclique (ou circulaire) est créée
lorsque le dernier élément possède une référence vers le premier élément (si la liste est doublement
chaînée, alors le premier élément possède aussi une référence vers le dernier). L'utilisation de ce
type de liste requiert des précautions pour éviter des parcours indéfinis, par exemple lors d'une
recherche vaine d'élément.

Une autre solution consiste à rendre la chaîne circulaire. Cela se fait en plaçant dans le champ lien
du dernier élément un pointeur vers le premier élément de la liste plutôt que la valeur NULL.
La liste circulaire est une sorte de liste simplement ou doublement chaînée, qui comporte une
caractéristique supplémentaire pour le déplacement dans la liste, "elle n'a pas de fin".
Pour rendre la liste sans fin, le pointeur suivant du dernier élément pointera sur le 1er élément de la
liste au lieu de la valeur NULL, que nous avons vu dans le cas des listes simplement et doublement
chaînées. Dans les listes circulaires, nous n'arriverons jamais à une position depuis laquelle nous ne
pourrons plus nous déplacer. En arrivant au dernier élément, le déplacement recommencera au
premier élément. En bref, il s'agit d'une rotation.
Ce sont des listes chaînées dont le dernier élément pointe sur le premier. Il est ainsi possible de
maintenir un pointeur courant qui désigne le dernier élément du parcours précédent, évitant ainsi de
recommencer le parcours à chaque fois.

Liste Circulaire (LC) : Il s’agit d’un ensemble de données organisées sur un anneau, avec les
caractéristiques suivantes :
– On aborde toujours l’anneau à partir d’une de ses cases, marquée d’une flèche sur la figure.
– On peut se déplacer également bien dans un sens que dans l’autre.

Algorithme de Création d’une Liste Circulaire simplement chainée

Début
| Allouer (T)
| Lire (T@.val)
| T@.suiv Nil
| Q T
| Tant Que (Non (Fin_saisie)) Faire
| | Allouer (P)
| | Lire(P@.val)
| | Q@.suiv P
| | Q P
| Fin Tant Que
| Q@.suiv  T
Fin
T

16
Q T

Q T P

3 -2

Q T P

3 -2

Q T P Q

3 -2

Q T P Q

3 -2

Q T P Q P

3 -2 5

Q T P Q P

3 -2 5

Q T P Q P

3 -2 5

Q T P Q P Q

3 -2 5

Q T P Q P Q P

3 -2 5 0

Q T P Q P Q P

3 -2 5 0 Fin De Saisie !!

Q T P Q P Q P Q

3 -2 5 0

17