*** Résumé sur les listes linéaires chainées ***

Note : avant de voir ce document il est vivement conseiller de voir le fichier “Introduction aux listes“
qui se trouve dans la rubrique “Révisions et remarques“ sur le site (à partir de la page 4) afin de
maitriser les opérations élémentaires sur les maillons de la liste.

Ce document contient des exemples sur quelques traitements qu’on peut faire dans une liste L.

Une liste linéaire chainée (unidirectionnel) est un ensemble de maillons (enregistrements) reliés entre
eux.
Il existe plusieurs types de listes :
1) Liste chainée unidirectionnel : où chaque maillon possède les informations utiles ainsi qu’un
pointeur contenant l’adresse de son suivant, sauf le dernier maillon qui n’a pas de suivant (Nil).
2) Liste chainée circulaire : c’est une liste chainée mais le suivant du dernier maillon est le premier
maillon.
3) Liste chainée bidirectionnel : où chaque maillon possède en plus des informations utiles, un
champ contenant l’adresse du suivant et un champ contenant l’adresse du précédent.
Les deux derniers types de listes seront vus en deuxième année. Donc on s’intéresse seulement à la liste
chainée unidirectionnel.

On distingue 3 classes d’opérations qu’on peut trouver dans le cas des listes :

I. Opérations de consultation : ce sont des opérations qui ne modifient ni les valeurs, ni les
chainages des maillons tel que : l’affichage de la liste, affichage d’un élément qui se trouve à une
position k, calcul de la moyenne, calcul du nombre d’éléments pairs, recherche d’une valeur, …

Soit L un pointeur qui contient l’adresse du premier élément d’une liste qui existe déjà.
On utilise un autre pointeur p qui va contenir à chaque fois l’adresse d’un des éléments de la liste, et qui
va servir pour parcourir les éléments de la liste.
Toutes les opérations de consultation nécessitent l’utilisation d’une boucle qui permet de parcourir
(passer par) tous les éléments de la liste, et qui a la forme suivante :
pL ; {p est initialisé par l’adresse du premier élément}
tant que (p<>Nil) faire {tant que p pointe encore sur un élément de la liste, donc on sort de la
boucle lorsque p=Nil c’est-à-dire p ne pointe sur aucun élément}
…………… traitements portants sur la valeur du maillon pointé par p (p^.valeur) ………….
pp^.suivant ; {p prend l’adresse du prochain maillon (p pointe vers le maillon suivant)}
fait ;

Exemple1 : Affichage de la liste

pL ; i1;
tant que (p<>Nil) faire tant que (i<=n) faire
Ecrire(p^.valeur) ; {Affichage d’un élément} Ecrire(T[i]) ; {Affichage d’un élément}
pp^.suivant ; ii+1 ;
fait ; fait ;
Remarque : On parcourt les éléments d’une liste avec un pointeur qui contient à chaque fois l’adresse d’un
élément, c’est exactement le rôle de l’indice qu’on utilise pour parcourir un vecteur, sauf que l’indice contient
à chaque fois la position d’un élément et non pas son adresse.
Donc ne confondez pas entre un pointeur et un indice.

Exemple2 : copier les éléments d’une liste ne dépassant pas 100 éléments dans un vecteur T.
pL ; i1 ;
 tant que (p<>Nil) faire
T[i]p^.valeur; {copier la valeur d’un maillon dans une case du vecteur T}
Pp^.suivant ; ii+1 ; {On doit advancer dans la liste et dans le vecteur}
fait ;

Exemple3 : calcul de la moyenne

pL ; s0 ; cpt0 ;
tant que (p<>Nil) faire
ss+p^.valeur; {Ajout de la valeur d’un élément à la somme}
cptcpt+1 ; {incrémenter le compteur du nombre d’éléments}
Pp^.suivant ;
fait ;
si (cpt=0) alors Ecrire(“impossible de calculer la moyenne car la liste est vide“) ;
sinon Moys/cpt ; Ecrire(“Moy=“, Moy) ;
finsi ;

Exemple4 : recherche d’une valeur val (indiquer si la valeur val existe dans la liste ou non)
pL ; existefaux ; {on suppose que val n’existe pas}
tant que (p<>Nil) et (existe=faux) faire {tant que ce n’est pas la fin de la liste et on n’a pas trouvé val}
Si(p^.valeur=val) alors existevrai; {On a trouvé la valeur donc on s’arrête}
Sinon pp^.suivant ; {on avance vers le prochain pour le vérifier}
Finsi ;
fait ;
si (existe=faux) alors Ecrire(“val n’existe pas“) ;
sinon Ecrire(“val existe“) ;
finsi ;

*******************************************************************************************
II. Opérations de modification des valeurs des éléments : par exemple : ajouter 1 à
tous les éléments pairs, faire une rotation à gauche ou à droite des éléments sans modifier les
chainages, trie d’une liste ….
Soit L un pointeur qui contient l’adresse du premier élément d’une liste qui existe déjà.
On utilise un autre pointeur p qui va contenir à chaque fois l’adresse d’un des éléments de la liste, et qui
va servir pour parcourir les éléments de la liste.
Toutes les opérations de modification des valeurs des éléments nécessitent l’utilisation de la boucle de
parcourt qu’on a déjà vue dans les opérations de consultation.
Exemple1 : Ajouter 1 à tous les éléments de rang pair et soustraire 1 à tous les éléments impairs.
pL ; i1; {i va représenter à chaque fois la position du pointeur p dans la liste}
tant que (p<>Nil) faire {tant que ce n’est pas la fin de la liste et on n’a pas trouvé val}
Si(i mod 2=0) alors p^.valeurp^.valeur+1; finsi ;
Si(p^.valeur mod 2<>0) alors p^.valeurp^.valeur-1; finsi ;
pp^.suivant ; ii+1 ; {on avance p et i}
fait ;

Exemple2 : Rotation à droite

Si (L^.suivant <>Nil) alors {la liste contient au moins 2 éléments}
pL^.suivant;
Tant que(p<>Nil) faire
{On permute à chaque fois la valeur d’un élément avec celle du premier élément en
commençons par le premier}
x L^.valeur ; L^.valeur p^.valeur ; p^.valeurx ;
 pp^.suivant ;
Fait ;
Finsi ;

Exemple3 : Rotation à gauche

Si (L^.suivant <>Nil) alors {la liste contient au moins 2 éléments}
xL^.valeur ; {on copie la valeur du premier éélment}
qL ; pL^.suivant ; {à chaque fois p est le suivant de q}
tant que (p<>Nil) faire
q^.valeurp^.valeur; {décalage d’une valeur à gauche}
qp; pp^.suivant; {avancer les deux pointeurs}
fait ;
q^.valeurx ; {on met la valeur du premier élément (x) dans le dernier élément}
finsi ;

*******************************************************************************************
III. Opérations de modification des chainages des éléments :
a. La création d’une liste :
1ère méthode :
- Insertion des éléments à la fin → L’ordre des éléments est préservé.
- On utilise cette méthode dans la plupart des cas sauf si on nous demande de créer une liste
inversée.
1) On initialise la liste à vide (LNil ;)
2) Boucle des données (il faut se poser la question quel est le nombre d’éléments à copier dans la liste et à
partir de quoi on les copies) : la boucle varie selon l’exercice
a) Créer un nouveau maillon avec p
b) Attribuer une valeur au nouveau maillon soit en lisant la valeur à partir de l’utilisateur, ou on la
copiant à partir d’un vecteur, matrice, ou une autre liste : peut varier selon l’exercice.
c) Si La liste est vide (L=Nil) {donc c’est le premier maillon} alors :
L et q pointent avec p
Sinon {ce n’est pas le premier maillon} alors :
Relier le dernier (q) avec le nouveau maillon (p), puis avancer q vers p

3) Si la liste n’est pas vide (L<>Nil) alors : mettre Nil sur le champ suivant du dernier maillon (pointé par p).

Exemple1 : on veut créer une liste à partir de n valeurs lues.

{On met L à Nil c’est pour dire que la liste est vide au départ}
LNil ;
pour i1 à n faire {car il y a n valeurs à mettre dans la liste}
{création d’un maillon avec p}
Allouer(p) ;
{La valeur du maillon vient de l’utilisateur, donc on va lire valeur puis l’affecter au maillon (p^)}
ecrire("donner une valeur"); lire(p^.valeur);
{Si la liste est vide donc le maillon qu’on vient de créer est le premier maillon}
si(L=NIL) alors
Lp ; {on pointe L sur p, à présent L est différent de Nil}
qp ; {on avance q vers p car q pointe vers le dernier}
sinon {ce n’est pas le premier maillon}
q ^.suivantp; {on relie le dernier maillon (q^) avec le nouveau maillon (p^)}
qp ; {on avance q vers p car q pointe vers le dernier}
finsi ;
fait ;
{Si la liste n’est pas vide alors attribuer la valeur Nil au champ suivant du dernier maillon}
Si (L<>Nil) alors p^.suivant Nil; {ou q^.suivantNil ;} finsi ;
fin

2ème méthode :
- Insertion des éléments au début → l’ordre des éléments est inversé.
- On utilise cette méthode dans la plupart des cas sauf si on nous demande de garder l’ordre des
valeurs.
1) On initialise la liste à vide (LNil ;)
2) Boucle des données (il faut se poser la question quel est le nombre d’éléments à copier dans la liste ou à
partir de quoi on les copies) : la boucle varie selon l’exercice
a) Créer un nouveau maillon avec p
b) Attribuer une valeur au nouveau maillon soit en lisant la valeur à partir de l’utilisateur, ou on la
copiant à partir d’un vecteur, matrice, ou une autre liste : peut varier selon l’exercice.
c) Relier le nouveau (p) avec le premier maillon (p), puis mettre L vers p

Exemple2 : on veut créer une liste à partir de n valeurs lues.

Procédure Création (var L : ^MaillonL, n :entier) ; {L pointe vers le premier élément}
Variable
p : ^ (MaillonL); {p pointe vers le nouveau élément}
i : entier;
début
{On met L à Nil c’est pour dire que la liste est vide au départ}
LNil ;
pour i1 à n faire {car il y a n valeurs à mettre sur la liste}
{création d’un maillon avec p}
Allouer(p) ;
{La valeur du maillon vient de l’utilisateur, donc on va lire valeur puis l’affecter au maillon (p^)}
ecrire("donner une valeur"); lire(p^.valeur);
{On relie le nouveau maillon (p^) avec le premier maillon (L^)}
p^.suivant L;
{A présent le premier élément a changé (c’est p^), alors on met L avec p}
Lp;
Fait;
Fin

Exemple3 : Créer une liste L à partir des éléments pairs de rang impair d’un vecteur T de taille n (n≤100).
LNil ;
pour i1 à n pas 2 faire {le rang est impair donc i=1, 3, 5….}
si(T[i] mod 2=0) alors {on copie uniquement les éléments pairs de T}
Allouer(p) ;
p^.valeurT[i];
si(L=NIL) alors Lp ; qp;
sinon q ^.suivantp; qp;
finsi ;
finsi ; {Attention à l’emplacement du “finsi;“}
fait ;
Si(L<>Nil) alors p^.suivant Nil; finsi ;

Exemple4 : Créer une liste L à partir des éléments d’une matrice de taille n*m (n≤20, m≤30).
LNil ;
{On utilise les deux boucles qui permettent de parcourir les éléments de la matrice M afin de les copier
un par un dans la liste L}
pour i1 à n pas 1 faire
pour j1 à m pas 1 faire
Allouer(p) ;
p^.valeurT[i, j]; {on copie un élment de M dans le nouveau maillon}
si(L=NIL) alors Lp ; qp;
sinon q ^.suivantp; qp;
finsi ;
fait ;
fait ;
Si(L<>Nil) alors p^.suivant Nil; finsi ;

Exemple5 : Soit L une liste déjà créée, on veut construite deux listes S, R tel que S est une copie de L et
R est le miroir de L.

On veut créer deux listes à partir des éléments d’une liste L déjà créée. Puisque S est une copie de L
donc on va utiliser la première méthode pour la créer, et puisque R est le miroir de L donc on va utiliser
la deuxième méthode de création pour la créer.

Commencons tout d’abord par identifier les pointeurs dont on aura besoin ainsi que le role de chacun.

Pour la liste S : puisque on va la créer avec la première méthode donc on a besoin de trois pointeurs :
S(pointe vers le premier élément), (qS : pointe vers le dernier élément), et (pS ; pointe sur le nouveau
élément créé).
Pour la liste R : puisque on va la créer avec la deuxième méthode donc on a besoin de deux pointeurs :
R(pointe vers le premier élément), et (pR ; pointe sur le nouveau élément créé)

Pour la liste L : en plus du pointeur L (qui pointe sur le premier élément), et puisque les éléments des deux
listes S et R sont copier à partir de la liste L donc on a besoin d’un pointeur p pour parcourir les éléments
de la liste L.

SNil ; SNil ; {Initialiser le deux listes à vide}

PL; {On initialise P par l’adresse du premier élément de la liste L}
Tant que (P<>Nil) faire {on utilise cette boucle car les maillons des deux listes qu’on va créer vont
recevoir leurs valeurs à partir de la liste L, donc on utilise la boucle qui permet de parcourir les éléments
de notre donnée (Les éléments de la liste L)}
{On commence par traiter la création d’un élément dans la liste S}
Allouer(pS) ;
pS^.valeurp^.valeur; {On copie la valeur d’un maillon de la liste L dans le maillon de liste S}
si(S=NIL) alors SpS ; qSpS;
sinon qS^.suivantpS; qSpS;
finsi ;
{A présent on va traiter la création d’un élément dans la liste R}
Allouer(pR) ;
pR^.valeurp^.valeur; {On copie la valeur du mème maillon de la liste L dans le maillon de liste S}
pR^.suivantR; RpR;

pp^.suivant; {On avance vers le prochain élément à copier de la liste L vers les deux listes S et R}
fait ;
Si(S<>Nil) alors pS^.suivant Nil; finsi ; {on ferme la liste S}

Exemple6 : créer une liste L à partir de plusieurs valeurs lues, l’arrêt se fera dès la lecture du 5 nombre
impair.
LNil ;
cpt0 ; {cpt est utilisé pour compter le nombre de valeurs impairs mises dans la liste}
Tant que (cpt<>5) faire {On utilise cette boucele car on s-arrète dès que cpt atteint 5}
Allouer(p) ;
Ecrire(“Donner une valeur “); lire(p^.valeur);
Si(p^.valeur mod 2<>0) alors
cptcpt+1 ; {on incrémente le nombre de valeurs impairs}
finsi ; {Attention à l’emplacement du “finsi;“}
si(L=NIL) alors Lp ; qp;
sinon q ^.suivantp; qp;
finsi ;
fait ;
Si(L<>Nil) alors p^.suivant Nil; finsi ;

*******************************************************************************************
b. L’insertion des éléments :
i. Insertion d’un élément (cas générale)
Pour insérer un élément dans la liste, il faut suivre la démarche suivante :
1) S’il s’agit d’une insertion au début (avant la tête).
a. Préparation du nouveau élément (allouer l’espace mémoire et lui attribuer la valeur).
b. Relier cet élément avec le premier.
c. Placer L sur le nouveau élément.
2) Sinon
a. Repérer le précédent.
b. Si le précédent n’existe pas : alors afficher un message ”insertion impossible”
c. Sinon {Insertion après la tête}
i. Préparation du nouveau élément (allouer l’espace mémoire et lui attribuer la
valeur).
ii. Mettre à jour les chainages entre les éléments (l’élément avec son suivant puis le
précédant avec l’élément)

Exemple1 : Insérer un élément à la kème position d’une liste L.

{1} si(k=1) alors {insertion en tête de la liste}
{a} Allouer(q) ; q^.valeur val ;
{b} q^.suivant L ; {c} Lq ;
sinon
{2} {a} i1; pL; existefaux;
tant que(p<>NIL)et(existe=faux) faire
si(i=k-1) alors existevrai;
sinon p p^.suivant; ii+1;
finsi;
fait ;
{b} si(existe=faux) alors ecrire(“insertion impossible : position trop grande”);
{c} sinon
{i} Allouer(q) ; q^.valeur val ;
{ii} q^.suivant p^.suivant; p^.suivantq ;
finsi ;
finsi ;

Remarque : lorsqu’on demande d’insérer une valeur val avant une certaine valeur x dans la liste, on doit
repérer le précédent le suivant de l’élément à insérer.

************************************************************************************
 ii. Insertion de plusieurs éléments (cas générale)
Pour insérer plusieurs éléments dans la liste, il est conseillé de suivre la démarche suivante :
{p va pointer sur l’élément à insérer, et q sur son précédent}
I) Pour chaque élément (q^)
1) S’il n’y a pas une insertion après q^
a. Avancer q
2) Sinon {cas d’insertion de p^} :
a. Préparer un nouveau maillon avec p et lui attribuer une valeur
b. S’il s’agit d’une insertion au début (q=L)
i. Relier le nouveau maillon (P^) avec le premier maillon (L^)
ii. Mettre L avec p
iii. Avancer q
c. Sinon (cas insertion après le premier) :
i. Relier le nouveau élément p^ avec le suivant de q^
ii. Relier le précédant ‘q^) avec le nouveau élément (p^)
iii. Placer q sur le nouveau suivant de p^.

Exemple2 : Insérer une valeur val après chaque occurrence d’une valeur y dans une liste L.
Ici on va utiliser deux pointeurs q : pointe sur le précédent (celui qui contient la valeur y), et p : pointe
sur le nouveau maillon à insérer après q^.
{I} qL;
Tant que (q<>Nil) faire {Tant qu’on n’a pas vérifié tous les éléments}
{1} Si(q^.valeur<>y) alors
{a} qq^.suivant;
{2} Sinon {q^.valeur=y}
{a} Allouer(p) ; p^.valeurval ;
{b} {le cas insertion au début ne se pose pas ici}
{c} {i} p^.suivantq^.suivant; {ii} q^.suivantp; {iii} qp^.suivant ;
Finsi ;
Fait ;

Exemple3 : Ecrire une procédure qui insert un “0“ avant chaque élément (valeur) impair.
Ici, puisqu’ils nous ont demandé d’insérer un 0 avant chaque valeur impair (et non pas après), alors on
aura besoin de 3 pointeurs p, q, r :
p : nouveau q : précédant de s : pointe sur la valeur impair (donc suivant du maillon
maillon “0“ p contenant le 0 à insérer (p))
Ici il s’agit d’insérer des maillons avec 0 comme valeur avant chaque maillon ayant une valeur impair
(et non pas la position impair).
On cherche les maillons ayants des valeurs impaires avec s, le pointeur q précède s toujours. Lorsqu’on
trouve une valeur impair on insert un maillon avec p contenant la valeur 0 entre q et s (qps).

{I} rL;
Tant que (r<>Nil) faire {Tant qu’on n’a pas vérifié tous les éléments}
{1} Si(r^.valeur mod 2 =0) alors
{a} qr ; rr^.suivant; {on avance le précédent (q) et le suivant (r)}
{2} Sinon {r^.valeur mod 2 <> 0}
{a} Allouer(p) ; p^.valeurval ;
{b} Si(r=L) alors {cas insertion au début}
{i} p^.suivantL; {ii} Lp;
{iii} qr ; rr^.suivant; {on avance le précédent (q) et le suivant (r)}
{c} sinon {cas insertion après le premier élément}
{i} p^.suivantr; {ii} q^.suivantp;
 {iii} qr ; rr^.suivant; {on avance le précédent (q) et le suivant (r)}
Finsi ;
Finsi ;
Fait ;
***********************************************************************************
iii. Insertion d’un élément à la fin d’une liste non vide
{préparation d’un nouveau maillon}
Allouer(P) ;
Ecrire(“Donner la valeur à insérer“) ; lire(P^.valeur) ;
P^.suivantNil ; {son suivant est Nil car il sera le dernier élément}

QL; {avancer Q jusqu’au dernier élément}

Tant que(Q^.suivant<>Nil) faire
QQ^.suivant;
fait;
Q^.suivantP; {relier le dernier élément (Q) avec le nouveau maillon (P)}

***********************************************************************************

iv. Création d’une liste triée : par insertion de n valeurs données

1) Initialiser L à Nil.
2) Pour i 1 à n
a. Allouer un espace pour un élément avec p et lui affecté une valeur lue.
b. Si la liste est vide ou la valeur de L est > x alors insérer p au début de la liste (relier p avec L,
puis mettre L avec p)
c. Sinon :
i. Parcourir la liste pour repérer la position d’insertion de x (q le précédent et r le suivant),
pour cela on avance tant que la valeur de r est < x
ii. Insérer p^ (relier le précédent (q^) avec le nouveau maillon (p^) et le nouveau maillon
(p^l avec le suivant (r^) de tel sorte à avoir q--> p--> r).

{1} LNil ;
{2} Pour i1 à n faire
{a : Préparer un nouveau maillon pointé par p}
Allouer(p); Ecrire (“donnez une valeur“); Lire (x);
p^.valeur x ;

{b} si(L=Nil) ou ((L<>Nil) et (L^.valeur>x)) alors {insertion au début}

p^.suivant L; L  p;
{c} sinon {insertion après le début}
r L ; {i : repérer la position d’insertion}
Tantque (r< >Nil ) et (r^.valeur < x) faire
qr; rr^.suivant;
fait ;
{ii : On insert p entre q et r}
q^.suivant p ; p^.suivantr;
Finsi ;
fait ;

*******************************************************************************************
 c. La suppression des éléments :
i. Suppression d’un élément (cas générale)
Pour supprimer un élément dans la liste, il faut suivre la démarche suivante :
{p va pointer sur l’élément à supprimer et q sur son précédent}
1) S’il s’agit du premier élément à supprimer
a. Placer p avec L
b. Avancer L
c. Supprimer l’élément (p^)
2) Sinon
a. Repérer la position de l’élément à supprimer (p) et celle de son précédent (q).
b. Si l’élément n’existe pas : alors afficher un message ”suppression impossible”
c. Sinon : suppression après la tête :
i. Mettre à jour les chainages entre le précédant et le suivant de l’élément
ii. Supprimer l’élément (p)

Exemple1 : Supprimer la première occurrence d’une valeur val à partir d’une liste L.
{1} Si (L^.suivant=val) alors {traiter le cas suppression du premier élément}
{a} PL; {b} LL^.suivant; {c} libérer(L);

{2} Sinon {repérer la première occurrence de val (p) ainsi son précédent (q)}
{a} PL; existefaux ; {On suppose que val n’existe pas}
Tant que(P<>Nil) et (existe=faux) faire
Si(p^.valeur) alors existevrai ;
Sinon QP; PP^.suivant;
fait;

{b}Si(existe=faux) alors Ecrire(“val n’existe pas“) ;

{c}Sinon {i} Q^.suivantP^.suivant; {ii} libérer(P);
Finsi ;
finsi;

*******************************************************************************************
ii. Suppression de plusieurs éléments (cas générale)
Pour supprimer plusieurs éléments dans la liste, il faut suivre la démarche suivante :
{p va pointer sur l’élément à supprimer et q sur son précédent}
I) Pour chaque élément (p^)
1) Si l’élément p^ n’est pas concerné par la suppression :
i. Placer q avec p
ii. Avancer p
2) Sinon (cas de suppression de p^) :
a. S’il s’agit du premier élément :
i. Avancer L
ii. Supprimer l’élément (p^)
iii. Mettre p avec L.
b. Sinon (cas de suppression après le premier) :
i. Relier le précédant avec le suivant de l’élément à supprimer
ii. Supprimer l’élément (p^).
iii. Placer p sur le suivant de q^.
Exemple2 : Supprimer toutes les occurrences d’une valeur val à partir d’une liste L.
{I} PL;
Tant que (P<>Nil) faire {Tant qu’on n’a pas vérifié tous les éléments}
{1} Si(P^.valeur<>val) alors
{i} QP; {ii} PP^.suivant;
{2} Sinon {p^.valeur=val}
{a} Si(p=L) alors {traiter le cas suppression du premier élément}
{i} LL^.suivant; {ii} libérer(L); {iii} PL;
{b} Sinon {cas suppression après le premier élément}
{i} Q^.suivantP^.suivant; {ii} libérer(P); {iii} PQ^.suivant ;
Finsi ;
Fait ;

*******************************************************************************************
iii. Destruction de la liste (suppression de tous les éléments) :
Consiste à supprimer tous les éléments de la liste un par un. Pour cela il suffit de
supprimer à chaque fois le premier élément jusqu’à que la liste devient vide (L=Nil).
Tant que (L<>Nil) faire
PL ;
LL^.suivant ;
Libérer(L) ;
Fait ;

*******************************************************************************************
iv. Suppression du dernier élément :
Si (L^.suivant=Nil) alors {la liste contient un seul élément}
libérer(L); LNil; {supprimer le premier élément, puis mettre Nil dans L}
Sinon
PL; {avancer p jusqu’au dernier élément, et q jusqu’à l’avant dernier élément}
Tant que(P^.suivant<>Nil) faire
QP; PP^.suivant;
fait;
Q^.suivantNil; {mettre Nil comme suivant de l’avant dernier car il va devenir le dernier}
libérer(P); {supprimer le dernier élément}
finsi;

*******************************************************************************************
d. Autres opérations :
Exemple 1 : Inverser une liste.
On a besoin de trois pointeurs qui pointent sur 3 maillons successifs.
{Les 3 pointeurs sont dans l’ordre suivant Q—> L—> P}

Q Nil; PL^.suivant;
Tantque(P<>Nil) faire
L^.suivantQ; {inverser le suivant d’un élément}
{avancer les trois pointeurs}
QL;
L L^.suivant;
P P^.suivant;
Fait ;
L^.suivantQ ; {inverser le suivant du dernier élément}
Exemple2 : Rotation à droite
Si (L^.suivant <>Nil) alors {Si la liste contient au moins 2 éléments}
pL ; {avancer p jusqu’au dernier élément, et q jusqu’à l’avant dernier élément}
tant que(p^.suivant<>Nil) faire
qp ; pp^.suivant ;
fait ;
p^.suivantL ; {relier le dernier élément avec le premier élément}
q^.suivantNil ; {mettre Nil comme suivant de l’avant dernier car il va devenir le dernier}
Lp ; {mettre L avec p}
finsi ;

Exemple3 : Rotation à gauche

Si (L^.suivant <>Nil) alors {si la liste contient au moins 2 éléments}
pL ; {avancer p jusqu’au dernier élément}
tant que(p^.suivant<>Nil) faire
pp^.suivant ;
fait ;
q L^.suivant ;{placer qu sur le deuxième élément}
p^.suivantL ; {relier le dernier élément avec le premier élément}
L^.suivantNil ; {mettre Nil comme suivant du premier élément}
Lq ; {mettre L avec q}
finsi ;

Exemple 4 : fusion de deux listes (voir solution exercice 5 TD)

Exemple 5 : éclatement d’une liste en deux listes (voir solution exercice 4 TD)….

****
J’espère que ce fichier va être bénéfique, et je m’excuse en cas d’erreur.

Pour information : Il y a un site google sur internet rédigé par une enseignante de
l’université de Blida1 qui contient des cours, exercices et examens corrigés sur plusieurs
modules (de la deuxième année licence jusqu’au 2ème année master).
Il suffit de taper sur la barre de recherche de google : « S.Aroussi »

Donc profitez pendant les vacances, et bon courage pour la suite.