Module : Programmation et structures de données.

MI- CNE 2- 2015-2016

Chapitre 3 : Listes chainées

Chapitre 3 : Listes chaînées

Comment traiter un nombre non connu de valeurs ? un tableau ferait il l’affaire ? Oui si l’on connait
le nombre maximal de ces valeurs bien que dans ce cas la solution tableau peut engendrer des pertes
d’espaces alloué mais non utilisé ou encore devenir inadéquate si le nombre maximal de valeur
change.

Dans la pratique, il arrive souvent que l'on ait besoin de représenter des objets dont on ne connaît pas à priori
la taille, ou dont la taille est variable selon les cas ou au cours du temps

Prenons l’exemple des moyennes des étudiants d’une promotion de 500 étudiants. Ces moyennes peuvent
être saisies dans un tableau de 500 réels et lorsque l’on nous demande de regrouper les étudiants admis dans
une structure de donnée et les ajournés dans une autre, nous aurons alors besoin de 2 tableaux de taille = 500
chacun alors qu’il y a de fortes chances que le nombre des admis soit beaucoup plus important que celui des
recalés et sur les 1000 cases de réels que nous avons déclarés pour nos deux tableau la perte d’espace serait
très importante.
Dans un autre cas de figure du même exemple des moyennes, les promotions changent d’une année à une
autre ce qui implique un changement (pouvant être très conséquent) des tailles des 3 tableaux.

il s’avère alors important de ne déclarer les éléments que lorsque l’on en a besoin. Le type tableaux ne
permet pas cela étant une structure de données statique dont la taille ne peut ni être incrémentée ni
décrémenter.

La solution ? Un nouveau type de données dynamique pouvant évoluer pour s'adapter à la représentation des
objets. Le principe de ce type est un mécanisme d'allocation et de libération dynamique d'espace mémoire :
on réserve des emplacements quand c'est nécessaire, que l'on libère quand on en a plus besoin.

Ce type de données est appelé « Listes ».

Cependant est afin d’utiliser ce nouveau type de données, il est nécessaire de rencontrer un autre type de
données dit « Enregistrement » sans lequel le type liste ne peut être utilisé.

I- Type Enregistrement

Un enregistrement est un élément qui contient habituellement plusieurs informations (cases) se rapportant au
même objet mais qui ne sont pas de même type.

Exemple : un enregistrement contenant la description d’un livre avec plusieurs informations (rubriques) : le
titre, le nom de l’auteur, l’année de l’édition, la maison de l’édition et le prix.
Il n’est alors pas possible de déclarer un tableau pour représenter un livre vu que la 1ère, la 2ème ainsi que la
4ème information sont de type chaîne de caractères alors que la 3ème est un entier et que la dernière
information est de type réel.

I- 1- Déclaration
Un enregistrement est un type connu par le programmeur qui doit préciser les cases qui le composent en
déclarant pour chacune un nom et un type.
Type
Nom = Enregistrement
Nom-case1 : Type_case1 ;
Nom-case2 : Type_case2 ;
…….
Nom-casen : Type_casen
Fin;

1
 Module : Programmation et structures de données. MI- CNE 2- 2015-2016
Chapitre 3 : Listes chainées
Note 1: "Type_case" peut être tout type de données : entier, réel, booleen, caractère, chaîne de caractère et
même tableau et enregistrement (ayant une autre composition de cases).
Note 2 : Les types des cases peuvent être identiques ou différents selon le besoin.

Exemples :
La déclaration suivante est celle relative au livre de l’exemple précédent :
Type
Livre = Enregistrement
Titre : Chaine de caractère ;
Auteur : Chaine de caractère ;
Année-ed : Entier ;
Editeur : Chaine de caractère ;
Prix : Reel
Fin;

La déclaration suivante est celle d’un enregistrement représentant un étudiant identifié par son nom, son
prénom, sa date de naissance, les moyennes des 5 modules ainsi qu’une mention (admis/ ajourné).

Type
Date = Enregistrement
JJ : 1.. 31 ;
MM : 1.. 12 ;
AAAA : Entier
Fin ;
Etudiant = Enregistrement
Nom, Prenom : Chaine de caractère ;
Date-N : Date ;
Moy1, Moy2, Moy3, Moy4, Moy5: Reel;
Mention : Chaine de caractère
Fin;
Note 3: La case Date-N est elle-même de type enregistrement déclaré avant l’enregistrement dont elle fait
partie.

I- 2- Utilisation
Pour utiliser une donnée de type enregistrement il est nécessaire de déclarer le type avec ses cases dans la
partie type puis terminer la déclaration dans la partie variable.

Exemple:

Variable
E: Etudiant;
L: Livre;

Dans le type tableau, manipuler une valeur parmi celles des cases du tableau nécessite l’utilisation du nom
du tableau suivi par la valeur de la case entre parenthèses (exp: T (5) c.-à-d. la 5ème valeur du tableau)
Ceci a donné la possibilité au développeur d’utiliser des boucles "pour" afin de parcourir toutes les cases du
tableau.

Dans le cas de l’enregistrement chaque case ayant son propre nom la manipuler nécessite l’utilisation du
nom de l’enregistrement suivi d’un point puis du nom de la case.

Exemple:
La case Nom de l’étudiant est manipulée E. Nom
La moyenne du 4ème module est E. Moy4
L’année de naissance de l’étudiant est E. [Link]

2
 Module : Programmation et structures de données. MI- CNE 2- 2015-2016
Chapitre 3 : Listes chainées
I-3- Exercices
A- Il est demandé de saisir les informations nom, prénom, date de naissance et moyennes d’un étudiant puis
d’afficher sa moyenne générale et de le déclarer admis ou ajourné.

Procedure Traitement (Var X: Etudiant);

Variable
MG : Reel ;
Debut
Lire (X. Nom, X. Prenom);
Lire (X. Date-N. JJ, X. [Link], X. [Link]);
Lire (X. Moy1, X. Moy2, X. Moy3, X. Moy4, X. Moy5) ;
MG  X. Moy1 + X. Moy2 + X. Moy3 + X. Moy4 + X. Moy5;
Si MG < 10 Alors
X. Mention  'Ajourné'
Sinon
X. Mention  ‘Admis’
FinSi ;
Ecrire ('L"étudiant ', X. Nom, X. Prenom, 'est ', X. mention, 'avec une moyenne générale = ',
MG)
Fin ;
B- Ecrire une fonction qui atteste si un livre est cher ou non (un livre cher a un prix dépassant 1500,00 DA).

Fonction Cher (livre1 : Livre) : Booleen ;

Debut
Si livre1. Prix > 1500 Alors
Cher  Vrai
Sinon
Cher  Faux
FinSi
Fin ;

II- Listes chaînées

Le principe de base des listes est le type pointeur. Une variable de type pointeur est une variable dont le
contenu est une adresse qui peut indiquer l'emplacement en mémoire d'une autre variable, créée
dynamiquement et ayant un type de base précis.

Note 4 : Quand une variable pointeur ne pointe sur aucun emplacement, elle doit contenir la valeur Nil (qui
est une adresse négative)

Si une structure contient une donnée avec un pointeur vers un élément de même composition on parle lors de
liste chaînée.

Une liste chaînée est donc une structure de données dans laquelle les éléments sont rangés linéairement.
Chaque élément (dit nœud) est lié à son successeur. Il est donc impossible d'accéder directement à un
élément quelconque de la liste (sauf le premier au quel on accède via un pointeur –généralement appelé tête
ou début de liste).

Tete Info Suiv Info Suiv Info Suiv Info Suiv

12 25 -4 11

Tete est le pointeur avec l’adresse du premier élément alors que chaque nœud est un enregistrement avec une
case (ici Info) pour la valeur à manipuler (ici : 12, 25, - 4 et 11) et une case (ici Suiv) de type pointeur avec
l’adresse où se trouve l’élément suivant.

3
 Module : Programmation et structures de données. MI- CNE 2- 2015-2016
Chapitre 3 : Listes chainées
Bien évidement, cette linéarité est purement virtuelle. A la différence du tableau, les éléments n'ont aucune
raison d'être voisins ni ordonnés en mémoire.

Les listes ont l'avantage d'être réellement dynamiques, c'est dire que l'on peut à loisir les rallonger (ajouter
des éléments) ou les raccourcir (supprimer des éléments), avec pour seule limite la mémoire disponible.
II- 1- Déclaration d’une liste

Type
P = ^ Element ;
Element = Enregistrement
Info : Type-C ;
Suiv : ^Element
Fin ;

Note 5 : Cette déclaration est toujours valable sauf qu’il faut à chaque fois préciser Type-C selon le type des
données manipulées (entier, reel, caractere, tableau…) .

II-2- Opérations de base sur les listes

La création d’une liste, le parcours d’une liste ainsi que l’ajout et la suppression d’un élément sont les
principales opérations effectuées sur les listes.

A- Création d’une liste

La création d’une liste revient à

1- Déclarer la tête de liste
2- Commencer à partir d’une liste vide (donc affecter le Nil à la tête avant de commencer)
3- des ajouts (insertions) répétitifs de nœuds qui vont constituer la liste.
Pour insérer un nouveau élément il est faut d’abord réserver un espace pour ce nœud. L’opération est
possible via la procédure prédéfinie ALLOUER (p) qui permet de repérer un espace suffisant pour le nœud
(Partie donnée et pointeur de l’élément qui va suivre). L’espace trouvé est alors réservé et son adresse dans la
mémoire est sauvegardée dans la variable pointeur p.

B- Parcours d’une liste

Les cases d’un tableau sont numérotées successivement. Le parcours dans un tableau revient alors à
initialiser un indice de parcours à 1 (se placer au niveau de la première case) puis d’incrémenter cet indice à
chaque fois pour passer d’une case à une autre.

Les éléments d’une liste ne sont pas numérotés mais reconnus par leurs adresses (l’adresse de chaque
élément étant sauvegardée dans la tête de la liste si c’est le premier sinon dans la partie pointeur de l’élément
qui le précède). Le parcours d’une liste revient alors à initialiser un pointeur à la valeur de la tête de liste puis
de lui affecter à chaque déplacement l’adresse se trouvant dans la partie pointeur de l’enregistrement jusqu’à
ne plus avoir d’élément suivant :

Pt  tete ;
Tantque Pt ≠ Nil Faire
Pt  Pt^. Suiv
FinTantque ;

Note 6 : La condition d’arrêt change lorsque l’on veut s’arrêter pus tôt que la fin de liste.
Exemple : si l’on veut se placer au niveau du dernier élément pour réaliser un quelconque traitement sur lui
la condition serait alors :
Tantque Pt^.suiv ≠ Nil Faire

4
 Module : Programmation et structures de données. MI- CNE 2- 2015-2016
Chapitre 3 : Listes chainées
C- Ajout d’un élément

On peut ajouter (insérer) un élément en début de liste (il deviendra le nouveau premier), en fin de liste (il
deviendra le dernier) ou encore en milieu de liste (entre deux éléments)

C-1- Ajout en début de liste

2
Tete

2 1
X

Procedure AjoutD (Var tete : P);

Variable
X: P;
Debut
Allouer (X);
Lire (X^.Info);
X^. Suiv  tete;
tete  X ;
Fin ;

Note 7 : Il est possible que l’élément à ajouter soit déjà créé et passé en paramètre de façon à ce que les
instructions "Allouer" et "lire" ne doivent pas apparaitre dans le sous algorithme d’ajout qui devient comme
suit :
Procedure AjoutD (Var tete : P; X: P);
Debut
X^. Suiv  tete;
tete  X ;
Fin ;

Le passage de l’élément à ajouter en paramètre (avec suppression des instructions d’allocation et de lecture)
est valable pour tous les type d’ajout (au début, à la fin et au milieu)

C-2- Ajout en fin de liste

Procedure AjoutF (tete : P);
Variable
X, Y: P;
Debut
Allouer (X); tete
Lire (X^.Info);
X^. Suiv  Nil;
Y  tete;
Tantque Y^.Suiv ≠ Nil Faire
Y  Y^. Suiv
FinTantque;
Y^. Suiv  X
Fin ;

Note 8 :
- L’entête du sous algorithme dans le cas où l’élément à ajouter est passé en paramètre est :
Procedure AjoutF (tete, X : P);

- Un ajout à la fin dans une liste vide revient à un ajout de début. Le test doit normalement être réalisé avant
l’appel du sous algorithme (dans le sous algorithme suivant sont ajoutées les lignes de code nécessaires à la
gestion du cas liste vide)

5
 Module : Programmation et structures de données. MI- CNE 2- 2015-2016
Chapitre 3 : Listes chainées
Procedure AjoutF (Var tete : P);
Variable
X, Y: P;
Debut
Allouer (X);
Lire (X^.Info);
X^. Suiv  Nil;
Si tete = Nil alors
tete  X
Sinon
Y  tete;
Tantque Y^.Suiv ≠ Nil Faire
Y  Y^. Suiv
FinTantque;
Y^. Suiv  X
FinSi
Fin ;

!!! Attention dans ce cas tête est passée par adresse (variable)

C-3- Ajout en milieu de liste

Cas 1 : (avant un élément dont l’adresse est dans "A")

Dans ce cas il faut connaître l’adresse de l’élément A que l’on veut précéder du nouveau élément X (X sera
placé donc avant A) :
A
Tete

X
Procedure AjoutM-AV (tete, A: P);
Variable
X, Y: P;
Debut
Allouer (X);
Lire (X^.Info);
Y  tete;
Tantque Y^.Suiv ≠ A Faire
Y  Y^. Suiv
FinTantque;
X^. Suiv  Y^. Suiv ; (* ou encore X^.Suiv  A ; *)
Y^. Suiv  X
Fin ;

Notes 9 :
- Une insertion au milieu (qui n’est ni un ajout au début ni un ajout à la fin) se fait entre deux éléments dans
une liste avec au moins deux éléments tout autre liste (vide (tete = Nil) ou avec un seul élément (tete^.suiv =
Nil)) ne peut être utilisée pour une insertion au milieu.

- L’entête du sous algorithme dans le cas où l’élément à ajouter est passé en paramètre est :
Procedure AjoutM-AV (tete, X, A: P);

6
 Module : Programmation et structures de données. MI- CNE 2- 2015-2016
Chapitre 3 : Listes chainées
Cas 2 : (après un élément dont l’adresse est dans "A")

Dans ce cas il faut connaître l’adresse de l’élément A que l’on veut faire suivre du nouveau élément X (X
sera placé donc après A) :
A
Tete

X
Procedure AjoutM-AP (tete, A: P);
Variable
X, Y: P;
Debut
Allouer (X);
Lire (X^.Info);
X^. Suiv  A^.Suiv ;
A^. Suiv  X
Fin ;

!!! L’entête du sous algorithme dans le cas où l’élément à ajouter est passé en paramètre est :
Procedure AjoutM-AP (tete, X, A: P);

D- Suppression d’un élément

On peut supprimer un élément en début de liste (le second deviendra le nouveau premier), en fin de liste
(l’avant dernier deviendra le dernier) ou encore en milieu de liste (entre deux éléments)

On peut supprimer un élément logiquement (il ne fera plus partie de la liste mais il existera toujours et son
adresse sera retournée dans un paramètre pour servir dans un autre traitement) ou le supprimer réellement
(suppression physique) en libérant son espace mémoire en utilisant la procédure prédéfinie Liberer (p) qui
permet de rendre au système d’exploitation le contrôle sur l’espace dont l’adresse est "p" occupé par le
nœud supprimé. Une suppression physique est donc une suppression logique suivie d’un "Liberer".

D-1- Suppression en début de liste

D-1-1- Suppression physique en début :
X

tete

Procedure SupprimeD (Var tete : P);

Variable
X:P;
Debut
X  tete ;
tete  tete^.Suiv;
Liberer (X)
Fin ;
!!!! Avant d’appeler ce sous algorithme la vérification de l’existence d’au moins un élément dans la liste
(liste non vide) est nécessaire. Dans le cas où le test n’est pas réalisé avant l’appel du sous algorithme, le
code devient le suivant :

7
 Module : Programmation et structures de données. MI- CNE 2- 2015-2016
Chapitre 3 : Listes chainées
Procedure SupprimeD (Var tete : P);
Variable
X:P;
Debut
Si tete = Nil Alors
Ecrire (‘erreur ! pas d’élément à supprimer’)
Sinon
X  tete ;
tete  tete^.Suiv;
Liberer (X)
FinSi
Fin ;

D-1-2- Suppression logique en début de liste :

X

tete

Procedure SupprimeD (Var tete, X : P);

Debut
X  Tete ;
tete  tete^.Suiv
Fin ;

!!! La vérification de l’existence d’au moins un élément dans la liste génère le sous algorithme
suivant :
Procedure SupprimeD (Var tete, X : P);
Debut
Si tete = Nil Alors
X  Nil ;
Sinon
X  Tete ;
tete  tete^.Suiv
FinSi
Fin ;

D-2- Suppression en fin de liste

D-2-1- Suppression logique en fin :

Y X

tete

Procedure SupprimeF (tete: P; Var X : P);

Variable
Y: P;
Debut
X  tete;
YX;
Tantque X^.Suiv ≠ Nil Faire
YX;
X  X^. Suiv
FinTantque;
Y^. Suiv  Nil
Fin ;

8
 Module : Programmation et structures de données. MI- CNE 2- 2015-2016
Chapitre 3 : Listes chainées
Dans le cas où le test d’une liste à élément unique (qui deviendra donc vide après la suppression) n’est pas
fait avant l’appel du sous algorithme, le code est le suivant :

Procedure SupprimeF (Var tete, X : P);

Variable
Y: P;
Debut
Si tete = Nil Alors
X  Nil ;
Sinon
X  tete;
YX;
Tantque X^.Suiv ≠ Nil Faire
YX;
X  X^. Suiv
FinTantque;
Si Y = tete Alors
Tete  Nil
Sinon
Y^. Suiv  Nil
FinSi
FinSi
Fin ;

D-2-2- Suppression physique en fin :

Ajouter l’instruction « Liberer (X) » avant la fin

Y X

Procedure SupprimeF (tete: P);

Variable
X, Y: P;
Debut
X  tete;
YX;
Tantque X^.Suiv ≠ Nil Faire
YX;
X  X^. Suiv
FinTantque;
Y^. Suiv  Nil ;
Liberer (X)
Fin ;

D-3- Suppression en milieu de liste

Dans ce cas, il est nécessaire de connaître l’adresse de l’élément à supprimer (paramètre transmis dans le
pointeur A).

Note 10 : Une suppression au milieu se fait dans une liste avec au moins 3 éléments et l’adresse de
l’élément à supprimer doit être valide et ne doit pas être ni celle du premier ni du dernier élément
sinon cela serait respectivement une suppression du début ou en fin (tous ces cas d’erreurs doivent
être traités avant d’appeler la procédure de suppression au milieu)

9
 Module : Programmation et structures de données. MI- CNE 2- 2015-2016
Chapitre 3 : Listes chainées
D-3-1- Suppression logique au milieu :
A

tete

Procedure SupprimeM (tete, A : P);

Variable
Y: P;
Debut
Y  tete;
Tantque Y^.Suiv ≠ A Faire
Y  Y^. Suiv
FinTantque;
Y^. Suiv  A^.Suiv ;
Fin ;

D-3-1- Suppression physique au milieu :

Ajouter l’instruction Liberer après la suppression logique.

Procedure SupprimeM (tete:P; Var A: P); A

Variable
Y: P; tete
Debut
Y  tete;
Tantque Y^.Suiv ≠ A Faire
Y  Y^. Suiv
FinTantque; Y
Y^. Suiv  A^.Suiv ;
Liberer (A)
Fin ;

II-3- Variantes de listes chaînées

A- Liste simplement chaînée

Une liste est dite simplement chaînée si chacun de ses nœuds contient une partie donnée (info) et
l’adresse du nœud qui le suit. Les opérations précédentes sont toutes valides sur ce type.

B- Liste doublement chaînée

Une liste est dite doublement chaînée si chaque nœud de cette liste contient une partie donnée,
l’adresse du nœud qui la suit et l’adresse du nœud qui la précède (donc simplement chaînée avec en
plus un chainage arrière).
Note 11 : Il n’y a pas d’élément avant le premier nœud, la valeur du pointeur Prec = Nil.

Tete Prec Info Suiv Prec Info Suiv Prec Info Suiv Prec Info Suiv

10
 Module : Programmation et structures de données. MI- CNE 2- 2015-2016
Chapitre 3 : Listes chainées
La déclaration des listes doublement chaînées nécessite donc un pointeur vers un enregistrement de
3 cases :
Type
PX = ^ Element ;
Element = Enregistrement
Prec : ^ Element;
Info : Type-C ;
Suiv : ^ Element
Fin ;

L’intérêt de ce type de listes est le déplacement d’un élément vers son prédécesseur en un seul pas.
Il est cependant nécessaire d’établir des changements dans les opérations de base à fin de garantir
cette flexibilité.

Exemples :
- Ajout Début
Procedure AjoutD (Var tete : PX);
Variable
X: PX;
Debut
Allouer (X);
X^. Prec  Nil ;
Lire (X^.Info); 3 1 2
Tete^.Prec  X ;
X^. Suiv  tete;
tete  X ;
Fin ;
Il fallait
- Mettre le Nil dans la case précédent (Prec) du nouveau nœud car ce dernier deviendra le premier et
donc n’aura aucun élément avant lui.
- remplacer le Prec de l’actuel premier élément (Nil) par l’adresse du nouveau nœud car ce dernier
sera placé avant lui.
- Suppression (On suppose que l’adresse de l’élément à supprimer existe réellement)
Procedure Supprime (Var tete, A : PX); 2
Variable A
Y: PX;
Debut tete
Si A = tete Alors
Debut
A^.Suiv^.Prec  Nil ;
Tete  A^.Suiv /*cas suppression au début*/
Fin 1
Sinon
Si A^.Suiv = Nil Alors -schéma suppression A au milieu -
A^.Prec^.Suiv  Nil /*cas suppression à la fin*/
Sinon
A^.Suiv^.Prec  A^.Prec ; /*cas suppression au milieu*/
A^.Prec^.Suiv  A^.Suiv;
Liberer (A) ;
FinSi
Fin ;

11
 Module : Programmation et structures de données. MI- CNE 2- 2015-2016
Chapitre 3 : Listes chainées
C- Liste circulaire

Une liste est dite circulaire si le dernier nœud de cette liste nous remet au premier nœud de cette
liste ; c.-à-d. que la case pointeur du dernier élément ne contient pas Nil mais l’adresse du premier
élément (tete).

L’absence du Nil dans ce type de liste (sauf le cas d’une liste vide) implique des conditions d’arrêt
en rapport avec la tête de liste. Il s’avère alors nécessaire de ne pas traiter tous les "n" éléments de
la liste dans la même boucle mais plutôt de traiter "n-1" éléments ensemble et de répéter le
traitement pour le nœud qui n’a pas été traité (ou encore utiliser la boucle répéter au lieu du
Tantque)

Tete Info Suiv Info Suiv Info Suiv Info Suiv

Note 12 : L’élément à traiter seul peut être le premier de liste (et avoir une boucle de traitement du
2ème au dernier élément) ou le dernier nœud de la liste (traiter du 1er à l’avant dernier élément dans
la boucle puis réécrire le traitement pour le dernier nœud.)

D- Liste circulaire doublement chaînée

Cette variation regroupe les caractéristiques des listes doublement chaînées (présence du Prec) et
des listes circulaires l’absence du Nil (car le Suiv du dernier nœud renvoi vers le premier élément et
le Prec du premier nœud renvoi vers le dernier élément.)

Tete Prec Info Suiv

Exemple :
Ecrire une fonction qui calcul le nombre de zéro dans une liste d’entiers. La liste est supposée déjà
lue.

Corrigé pour liste simplement chaînée :

Fonction calcul-SChai (L : P) : entier ;

Variable
Pt : P ;
Co : Entier ;
Debut
Co  0 ;
Pt  L ;
Tantque Pt ≠ Nil Faire
Si Pt^.Info = 0 Alors
Co  Co + 1
FinSi ;
Pt  Pt^. Suiv
FinTantque ;
Calcul  Co ;
Fin ;

12
 Module : Programmation et structures de données. MI- CNE 2- 2015-2016
Chapitre 3 : Listes chainées
Corrigé pour liste circulaire :
Fonction calcul-DChai1 (L : PX) : entier ;
Variable
Pt : PX ;
Co : Entier ;
Debut
Co  0 ;
Pt  L ;
Tantque Pt^. Suiv ≠ L Faire /* Traitement des N-1 premiers nœuds ensemble*/
Si Pt^.Info = 0 Alors
Co  Co + 1
FinSi ;
Pt  Pt^. Suiv
FinTantque ;
Si Pt^.Info = 0 Alors /* Traitement du dernier nœud seul*/
Co  Co + 1
FinSi ;
Calcul  Co ;
Fin ;

Ou encore

Fonction calcul-DChai2 (L : P) : entier ;

Variable
Pt : P ;
Co : Entier ;
Debut
Co  0 ;
Pt  L ;
Repeter
Si Pt^.Info = 0 Alors
Co  Co + 1
FinSi ;
Pt  Pt^. Suiv
Jusqu’a Pt = L ;
Calcul  Co ;
Fin ;

13