Le document traite des représentations contiguës et chaînées des données, en soulignant les avantages et inconvénients de chaque méthode. La représentation contiguë permet un accès rapide aux données mais pose des problèmes lors des mises à jour, tandis que la représentation chaînée facilite les insertions et suppressions sans décalages. Le texte aborde également la création et la manipulation de listes chaînées, en détaillant les algorithmes correspondants.

1. République Algérienne Démocratique et Populaire
Université des Sciences et de la Technologie Houari Boumediene
Faculté d’Electronique et d’Informatique
Département Informatique
Cours Algorithmique de 1ere Année MI
Présenté par : Dr. B. BESSAA

2. 2
Un petit retour en arrière !
On a vu que lorsqu’un ensemble de variables ont les mêmes propriétés
et concernent un même objet (par exemple : les notes d’un étudiant),
on les regroupe dans une seule variable de type Tableau. Ce qui facilite
la manipulation des éléments de cet ensemble.
Oui, oui on vient juste de le voir.
On a vu aussi, dans le cours des pointeurs, qu’à une variable de type
Tableau, on fait correspondre une seule adresse : c’est l’adresse de
base. Et à partir de cette adresse, on peut retrouver l’adresse (@) de
n’importe quel élément du tableau juste en ayant son indice (I), en
utilisant la fameuse formule : @ = N*(I-1)+@1
où @1 est l’adresse de base
Vous êtes d’accord ? Vous vous souvenez de ça ?
Bien, alors comment cela est possible ?

3. 3
Et bien ceci est possible, parce que les éléments du tableau sont stockés
en mémoire l’un à coté de l’autre, ils sont voisins, il sont adjacents. On
dit que les éléments du tableau sont contigus.
Au fait c’est une manière de représentation des données, on parle de la
représentation contigüe.
L’avantage principal de la représentation contigüe, est qu’à partir d’une
adresse de base, on peut accéder directement à un élément de
l’ensemble juste en ayant sa position (son indice). Ce qui permet
d’accélérer l’accès aux données.
E1 E2 E3 E4 E5 E6 E7 E8
1 2 3 4 5 6 7 8
Mais malheureusement, la représentation contigüe possède deux
inconvénients majeurs.

4. 4
1- La taille de la structure de donnée
Mais on peut utiliser un tableau dynamique. Et dans ce cas on n’a pas
besoin de spécifier la taille max du tableau.
En effet, dans une représentation contigüe, on doit spécifier la taille de
la structure de donnée (la taille max du tableau). Et donc une fois le
tableau plein, on ne peut pas ajouter des éléments.
Et quel est le deuxième inconvénient ?
Bonne réflexion, oui, avec un tableau dynamique, on n’a pas besoin de
spécifier la taille dans la partie déclaration, mais au moment de
l’allocation dynamique (en exécution), il faut préciser la taille. Donc
même avec un tableau dynamique la taille est limitée.
Le deuxième est aussi important que le premier.
2- La mise à jour des données

5. 5
2- La mise à jour des données
Alors si jamais on veut supprimer un élément ou insérer dans le mesure
du possible (si l’espace le permet), on doit faire toute une gymnastique
qui prend beaucoup de temps.
Trèèèès bien, voici un exemple:
Soit un tableau de 10 éléments. Pour supprimer le deuxième élément,
on doit décaler tous les éléments à partir du troisième d’une case à
gauche (donc 8 décalages), ensuite on réduit la taille exacte (N) du
tableau
Oui on doit faire un décalage de tous les éléments.
4 -1 3 8 1 -8 13 15 7 303 8 1 -8 13 15 7 30
3 8 1 -8 13 15 7 30
Alors ça c’est pour un tableau de 10, imaginez le travail à faire pour un
tableau de 1000 ???!!!! La même chose se fait pour l’insertion.
4 -1 3 8 1 -8 13 15 7 30

6. 6
Donc que ça soit Statique ou Dynamique
La représentation Contigüe possède un avantage très intéressant
(l’accès rapide aux données), mais elle a un inconvénient majeur dans le
cas d’une mise à jour des données.
Bien, quand on veut trouver des solutions à des problèmes pareils, il
faut viser les inconvénients et essayer de trouver des remèdes. Là on a
dit qu’il y a deux inconvénients. On va essayer de les éliminer un par un.
Commençant par le plus important: le deuxième.
Essayons donc de trouver une solution pour éviter les décalages pour
les opérations de suppressions ou d’insertions.
Et alors, est-ce-qu’il y a solution à ce problème ?
Cette manière de représentation est conseillée dans les problèmes où la
mise à jour est rare : conception d’un dictionnaire par exemple.
Par contre, elle déconseillée dans les cas où la mise à jour est fréquente.

7. 7
Le problème du décalage est dû au fait qu’il y a un ordre entre les
éléments qu’il faut respecter, c’est un lien implicite entre les éléments.
Alors si on veut éviter ce décalage, il faut casser cet ordre. Mais si on le
casse on perd le lien entre les éléments. La solution est de rendre ce
lien explicite.
J’explique, soit cinq personnes alignés l’un après l’autre, et chacun
possède un numéro.
Quel le numéro du deuxième ?
Non, on n’a rien compris !!!
19 82935C’est 19.
Bien, quel le numéro du
quatrième ?
C’est simple 29.
Donc vous avez pu répondre facilement car vous voyez l’ordre entre ces
personnes, il suffit de compter.

8. 8
Alors maintenant je vais changer la situation, et je présente les mêmes
personnes de cette manière
Quel le numéro du troisième ? 198
29 3
5
Euuuuh, on ne sait pas !!!
Oui, et vous ne pouvez pas le savoir, parce qu’on a cassé l’ordre initial
entre les personnes qui était visuel (implicite).
Et pour que vous puissiez répondre à cette question, il vous faut cette
information. Mais comme elle n’est pas apparente, il faut la rendre claire
(explicite)
Et comment ?
On va voir.

9. 9
Alors maintenant je vais demander à chacun de ces personnes de se
souvenir du numéro de son voisin gauche. Et moi je ne garde que le
numéro du premier, c’est le numéro 5.
Je repose la question, quel est
le numéro du troisième ?
19
3
8
fin
29
8
3
29
5
19
Alors, le premier c’est 5, son voisin le deuxième, c’est 19 ensuite son
voisin le troisième c’est le numéro 3.
Bien, vous voyez donc, maintenant le lien devient explicite, vous le
voyez.
Entre nous, je vous rappelle l’ordre initial, c’était : 5-19-3-29-8
Dans ce cas, la nouvelle situation sera:

10. 10
19
3
8
fin
29
8
3
29
5
19
Oui, mais comment ça résout le problème du décalage ?
C’est simple, si on veut supprimer le deuxième par exemple, il suffit
de dire au premier que ton voisin n’est plus 19 mais le voisin de 19
qui est 3. Et donc on aura un nouveau chainage sans faire aucun
décalage.
En effet, dans la nouvelle situation, il existe un lien de chainage explicite
entre ces personnes:
5
3
On appelle cette représentation : La représentation Chainée

11. 11
La Représentation Chainée d’un ensemble d’éléments ordonnés,
consiste à ajouter à chaque élément une information sur son suivant.
Et justement, les structures de données utilisant ce mode de
représentation, s’appellent:
Les Listes Chaînées
Il existe plusieurs types de listes chainées, linéaires et non linéaires
(LLSC, LLDC, LLCC, Arbres, Graphes,…), nous allons nous intéresser dans
ce cours aux (LLSC):
Donc chaque élément sera représenté par deux parties (Enregistrement)
1- Information : qui décrit l’élément lui-même.
2- Suivant : qui donne information (code) sur le suivant.
Listes Linéaires Simplement Chaînées
Une LLSC est une suite ordonnée d’éléments de (maillons) de même
type, reliés entre eux par un chainage simple (dans un seul sens).
Un maillon (élément) est un enregistrement composé de deux champs:
1- Information 2- Suivant

12. 12
On peut toujours exploiter les tableaux (organisation contigüe) pour
représenter une LLSC (tableau d’enregistrements), dans ce cas le
suivant sera l’indice de l’élément suivant dans le tableau. Le dernier
élément aura l’indice 0 pour son suivant. La liste sera définie par l’indice
du premier élément.
Exemple:
Soit la liste suivante composée de 6 éléments, avec le premier élément
qui se trouve à l’indice 4:
1 2 3 4 5 6 7 8 9
5.25 8.13 10.1 18.2 5.1 -1.8
7 0 5 1 2 3
Indices
Information
Suivant
La représentation contigüe équivalente est:
18.2 5.25 -1.8 10.1 5.1 8.13

13. 13
Effectivement, en plus son implémentation est un peu compliquée.
Donc cette représentation n’est pas intéressante, en passe alors à
l’élimination du deuxième inconvénient de la représentation contigüe
qui était justement la taille limitée du tableau.
Mais dans ce cas on aura toujours le problème de la taille limitée du
tableau !!!
Alors là c’est plus simple. Pensons au chainage qu’on a fait ?!
Les pointeurs ???
Exactement, on voit déjà dans le champ suivant du maillon de la liste, la
notion de l’adresse de l’élément suivant, donc un pointeur vers
l’élément suivant.
En utilisant les pointeurs, une liste sera définie par un pointeur sur le
premier maillon (élément), et le suivant sera lui aussi un pointeur vers
un maillon (élément suivant). Et donc, théoriquement, la taille ne sera
pas limitée.

14. 14
Déclaration d’une liste (LLSC)
Type
<NomMaillon> = Enregistrement
<IdInfo>:<TypeElt>;
<IdSuivant>: ^ <NomMaillon>;
Fin;
<TypeElt>: est le type de l’information qui peut être simple ou structuré.
On a deux notations possibles pour déclarer une liste:
Notation 1:
Avec cette notation, les variables représentant des listes seront
déclarées par des pointeurs vers <NomMaillon>.
Exemple
Type Eliste = Enregistrement
Info : reel;
Suiv : ^ Eliste;
Fin;
Var L,Q : ^Eliste;

15. 15
Type <NomPtr> = ^ <NomMaillon>;
<NomMaillon> = Enregistrement
<IdInfo> : <TypeElt>;
<IdSuivant> : <NomPtr>;
Fin;
Notation 2:
Avec cette notation, les variables représentant des listes seront
déclarées comme étant des <NomPtr>.
On peut utiliser l’une des deux, mais personnellement je préfère la
deuxième, elle évite d’utiliser à chaque fois le symbole pointeur (^).
Exemple
Type Pliste = ^ Eliste;
Eliste = Enregistrement
Info : reel;
Suiv : Pliste;
Fin;
Var L,Q : Pliste;

16. 16
Enfin nous pouvons présenter un résumé sur la représentation des
données avec une comparaison des performances :
Représentation
Contigüe
(Tableaux)
Chainée
(Listes)
Mémoire
Taille
Accès
MAJ
Statique, Dynamique Dynamique, (Statique)
Limitée Non Limitée
Direct, Séquentiel Séquentiel
Complexe Simple
V
S

17. 17
Le type liste n’est pas un type prédéfini, c’est l’utilisateur qui le définit
de sa manière, il faut juste respecter la syntaxe de déclaration.
Manipulation Listes Chaînées
Pour tout ce qui suit, on va utiliser une liste d’entiers, mais le principe
des algorithmes reste le même pour tout autre type d’élément de la
liste.
La manipulation, dépend donc du problème à résoudre. Cependant il y a
des opérations standards qu’on peut retrouver dans différents
problèmes.
Nous allons voir principalement, la création des listes, l’insertion et la
suppression et quelques applications.
Une remarque importante lorsqu’on manipule une liste, il faut retenir
que le premier élément de la liste (Tête de liste) est le seul point d’accès
à la liste, et il ne faut surtout pas le perdre, car si on le perd, tous les
autres éléments seront perdus.
Si on perd la Tête on devient Fou

18. 18
a- LIFO (Last In First Out) : dans ce cas chaque élément ajouté est
placé en tête de liste, et donc le dernier élément ajouté sera le
premier de la liste.
b- FIFO (First In First Out) : dans ce cas chaque élément ajouté est
placé à la fin de la liste, et donc le premier élément ajouté sera le
premier de la liste.
1- Création des listes chainées
Il existe deux modes de création d’une liste chainée:
Déclaration
Type Pliste = ^ Eliste;
Eliste = Enregistrement
Info : entier;
Suiv : Pliste;
Fin;

19. 19
Création LIFO (Last In First Out)
Pour créer une liste en mode LIFO, on utilise deux Pointeurs:
- Un pointeur pour la Tête de liste.
- Un pointeur intermédiaire pour créer les éléments.
L’opération passe par les étapes suivantes:
Soient T et P les deux pointeurs à utiliser.
1- Initialiser la tête T à Nil. T Nil ;
2- Créer un maillon avec P. Allouer(P);
3- Remplir la partie information. Lire(P^.Info);
4- Enchainer avec la tête T. P^.Suiv T;
5- Transmettre l’adresse de P à T. T P;
6- Aller à 2 pour créer l’élément suivant (boucle de création)
Exemple
Soit à créer une liste composée des éléments : 5 - 3 - 6
Donc le premier élément de la liste sera 6.

20. 20
0- Var T,P : Pliste;
1- T Nil ;
2- Allouer(P);
3- Lire(P^.Info);
4- P^.Suiv T;
5- T P;
6- Aller à 2 pour créer l’élément suivant (boucle de création).
On va donc suivre ces étapes pour créer la liste : 5 - 3 - 6
Créer 2 espaces statiques ayant
pour adresses @T et @P
@T @PNil
Créer un espace dynamique pour un
maillon (2 champs). Soit à l’adresse
@1, puis mettre @1 dans P (@P)
@1
Lecture de 5
5
Transmettre Nil au champ
Suivant de l’adresse @1
Nil
@1
Mettre P (@1) dans T
T pointe vers @1
@1
Fin de la première itération:
T (Tête) pointe vers le premier élément @1 (5)
Le suivant de 5 est Nil (donc c’est aussi le
dernier).
P pointe aussi vers 5 ( ne dérange pas).

21. 21
0- Var T,P : Pliste;
1- T Nil ;
2- Allouer(P);
3- Lire(P^.Info);
4- P^.Suiv T;
5- T P;
6- Aller à 2 pour créer l’élément suivant (boucle de création).
la liste à créer : 5 - 3 - 6
@T @P@2
@1
5
Nil
@1@1
Fin de la deuxième itération:
T (Tête) pointe vers le deuxième élément @2 (3)
Le suivant de 3 est 5.
P pointe aussi vers 3 ( ne dérange pas).
Deuxième Itération : Ajouter 3
@2
Créer 2eme maillon (@2)
Nouveau lien pour P
@2
Lecture de 3
3
Transmettre @1 au champ
Suivant de l’adresse @2
Chainage de @2 vers @1 @1
Mettre P (@2) dans T
T pointe vers @2
Nouveau chainage pour T
@2

22. 22
0- Var T,P : Pliste;
1- T Nil ;
2- Allouer(P);
3- Lire(P^.Info);
4- P^.Suiv T;
5- T P;
6- Aller à 2 pour créer l’élément suivant (boucle de création).
la liste à créer : 5 - 3 - 6
@T @P@2
@1
5
Nil
@2
Fin de l’opération
T (Tête) pointe vers le troisième élément @3 (6)
Le suivant de 6 est 3, le suivant de 3 est 5.
P pointe aussi vers 6 ( ne dérange pas).
Deuxième Itération : Ajouter 6
@2
3
@1
Créer 3eme maillon (@3)
Nouveau lien pour P
@3
@3
Lecture de 6
6Transmettre @2 au
Suivant de l’adresse @3
Chainage de @3 vers @2 @2
Mettre P (@3) dans T, T pointe vers @3; Nouveau chainage pour T
@3
En ignorant le pointeur intermédiaire P, la liste de tête T sera :

23. 23
L’algorithme permettant de créer un liste de N entiers peut donc s’écrire
Algorithme de création LIFO
Algorithme CreerLifo;
Var T,P : Pliste;
I,N : entier;
Debut
Lire(N); //nombre d’éléments de la liste
T ← Nil ; //initialiser à vide
Pour I ← 1 à N //boucle de création
Faire
Allouer(P);
Lire(P^.Info);
P^.Suiv ← T;
T ← P;
Fait;
Fin.

24. 24
On peut transformer cet algorithme en procédure avec 2 paramètres
T et N, ils seront donc enlevés des variables locales.
Algorithme de création LIFO
Procedure CreerLifo(E/S/ T:Pliste ; E/ N : entier);
Var P : Pliste;
I : entier;
Debut
T ← Nil ; //initialiser à vide
Pour I ← 1 à N //boucle de création
Faire
Allouer(P);
Lire(P^.Info);
P^.Suiv ← T;
T ← P;
Fait;
Fin;

25. 25
Création FIFO (First In First Out)
Pour créer une liste en FIFO, il faut d’abord créer la tête, ensuite créer
les autres éléments puis les enchainer à la tête, pour cela on utilise
trois Pointeurs:
- Un pointeur pour la Tête de liste (T).
- Un pointeur intermédiaire (P) pour créer les éléments.
- Un pointeur pour sauvegarder le dernier élément créé (Q).
L’opération passe par les étapes suivantes:
Soient T, P et Q les trois pointeurs à utiliser.
1- Initialiser la tête T à Nil.
2- Créer la tête T.
3- Initialiser Q avec T. (Q représente dernier élément créé : Queue)
4- Créer un maillon P.
5- Enchainer avec Q (ajouter P à la fin)
6- Affecter P à Q. (P devient le dernier élément)
7- Aller à 4 pour créer l’élément suivant. (boucle de création)
8- Affecter Nil au suivant de Q. (mettre fin à la liste)

26. 26
Exemple
Soit à créer une liste composée des éléments : 5 - 3 - 6
Donc le premier élément de la liste sera 5.
0- Var T,P,Q : Pliste;
1- T Nil ;
2.1- Allouer(T);
2.2- Lire(T^.Info);
3- Q T;
Création du premier élément (Tête)
Créer 3 espaces statiques ayant
pour adresses @T , @Q et @P
@Q @P@T Nil
Créer un espace dynamique pour un
maillon (2 champs). Soit à l’adresse
@1, puis mettre @1 dans T (@T)
@1
@1
Lecture de 5
5
Mettre T (@1) dans Q
Q pointe vers @1 (dernier élément créé)
@1
Fin de création de la Tête
T pointe vers le premier élément @1 (5).
Q pointe vers le même élément.

27. 27
4.1- Allouer(P);
4.2- Lire(P^.Info);
5- Q^.Suiv P;
6- Q P;
7- Boucle
8- Q^.Suiv Nil;
Créer les autres éléments (3 – 6)
@Q @P@T
@1
@1
5
@1
Première itération : Ajouter 3
Créer un espace dynamique pour un
maillon (2 champs). Soit à l’adresse
@2, puis mettre @2 dans P (@P)
@2
@2
Lecture de 3
3
Transmettre @2 au Suivant de Q (@1)
Chainage de @1 vers @2
@2
Mettre P (@2) dans Q, Q pointe vers @2; Nouveau chainage pour Q
@2
Fin de la première itération:
T (Tête) pointe vers le premier élément
@1 (5). Le suivant de 5 est 3.
P et Q pointent vers 3 ( ne dérange pas).

28. 28
4.1- Allouer(P);
4.2- Lire(P^.Info);
5- Q^.Suiv P;
6- Q P;
7- Boucle
8- Q^.Suiv Nil;
Créer les autres éléments (3 – 6)
@Q @P@T
@1
@1
5
@2
Deuxième itération : Ajouter 6
@2
@2
@2
Créer un espace dynamique pour un maillon (2
champs). Soit à l’adresse @3, puis mettre @3
dans P (@P). Nouveau chainage pour P
@33
@3
Lecture de 6
6
Transmettre @3 au Suivant de Q (@2)
Chainage de @2 vers @3
@3
Mettre P (@3) dans Q, Q pointe vers @3; Nouveau chainage pour Q
@3

29. 29
4.1- Allouer(P);
4.2- Lire(P^.Info);
5- Q^.Suiv P;
6- Q P;
7- Boucle
8- Q^.Suiv Nil;
Créer les autres éléments (3 – 6)
@Q @P@T
@1
@1
5
Deuxième itération : Ajouter 6
@2
@2
@33
@3
6
@3
@3
Fin de la boucle, mettre le suivant de Q (@3) à Nil
Nil
Fin de l’opération:
T (Tête) pointe vers le premier élément @1 (5).
Le suivant de 5 est 3, Le suivant de 3 est 6.
P et Q pointent vers 6 ( ne dérange pas).
En ignorant les pointeurs intermédiaires P et Q, la liste de tête T sera :

30. 30
L’algorithme permettant de créer un liste de N entiers peut donc s’écrire
Algorithme de création FIFO
Algorithme CreerFifo;
Var T,P,Q : Pliste;
I,N : entier;
Debut
Lire(N); //nombre d’éléments de la liste
T ← Nil ; //initialiser à vide
Si N ≠ 0 Alors
Allouer(T); Lire(T^.Info); // créer la tête
Q ← T; //dernier élément créé
Pour I ← 2 à N //boucle de création
Faire
Allouer(P); Lire(P^.Info);
Q^.Suiv ← P;
Q ← P;
Fait;
Q^.Suiv ← Nil; //mettre fin à la liste
Fsi;
Fin.

31. 31
La même chose ici, on peut transformer cet algorithme en procédure
Algorithme de création FIFO
Procedure CreerFifo(E/S/ T : Pliste ; E/ N:entier);
Var P,Q : Pliste;
I : entier;
Debut
T ← Nil ; //initialiser à vide
Si N ≠ 0 Alors
Allouer(T); Lire(T^.Info); // créer la tête
Q ← T; //dernier élément créé
Pour I ← 2 à N //boucle de création
Faire
Allouer(P); Lire(P^.Info);
Q^.Suiv ← P;
Q ← P;
Fait;
Q^.Suiv ← Nil; //mettre fin à la liste
Fsi;
Fin.

32. 32
Remarque
Pour simplifier le schéma représentant une liste, on peut négliger les
adresses, par exemple, la liste {8,5,-1,2} sera représentée par le schéma:
8 5 -1 2 Nil
T
Mais comment on peut savoir si la liste est FIFO ou LIFO ?
Bon, FIFO ou LIFO sont des modes de création, et non pas une
caractéristique de la liste. Donc, une fois créée, on ne cherche pas à
savoir comment elle a été créée. L’essentiel, on a une suite d’éléments
avec une Tête comme point d’accès.
Alors, on passe maintenant à l’insertion dans une liste. On suppose
qu’on à déjà une liste à laquelle on veut ajouter un élément.

33. 33
Soit T la tête d’une liste donnée, et X un élément (partie info) à insérer
dans cette liste.
2- Insertion dans une liste chainée
Insérer au début ou à la fin, c’est clair, mais le milieu ?! Comment
on va le définir ?
Bien, quand on dit milieu, ce n’est pas dans le sens moitié, mais c’est
quelque part dans la liste, autre que le début et la fin.
Trois cas se présentent pour l’insertion:
1- Insérer au début.
2- Insérer à la fin.
3-Insérer au milieu.
Comment le définir ? Là c’est le cas d’utilisation qui le définit, ça peut
être une position (Ex: insérer à la 3 position), comme ça peut être avant
ou après une valeur donnée, ou encore avant ou après une adresse
donnée,...
Ce qui nous intéresse c’est le principe d’insertion au milieu,
indépendamment du cas de figure.

34. 34
Pour insérer au début, on utilise un pointeur intermédiaire (P) et on
passe par les étapes suivantes:
1- Créer l’élément contenant X. Allouer(P) ; P^.Info ← X;
2- Etablir un lien de chainage entre P et T. P^.Suiv ← T ;
3- Déplacer la Tête (T) vers P. T ← P ;
2.1- Insertion au début
ATTENTION, l’ordre des actions est très important
Exemple: Soit la liste suivante {13,-5,2}, et on veut insérer X=7 au début
@T
@1
@1
13 @2
@2
@3-5 2
@3 Nil
1-
@4 7
@P @42-
@1
3-
@4
En ignorant le pointeur intermédiaire P, la liste de tête T sera :

35. 35
La procédure a 2 paramètres T et X. T est passé par référence (E/S), car
la tête va changer.
Procédure insertion au début
Procedure InsertDebut(E/S/ T:Pliste ; E/ X : entier);
Var P : Pliste;
Debut
Allouer(P);
P^.Info ← X;
P^.Suiv ← T;
T← P;
Fin;
No problem !, même si elle est vide (T=Nil), ça marche, dans ce cas
l’action P^.Suiv ← T va affecter Nil au suivant, et on aura donc une liste
T avec un seul élément.
Et si la liste initiale est vide?

36. 36
Pour insérer à la fin, on utilise 2 pointeurs intermédiaires P et Q et on
passe par les étapes suivantes:
1- Parcourir la liste pour atteindre la fin (boucle avec Q)
2- Créer l’élément contenant X. Allouer(P) ;
P^.Info ← X; P^.Suiv ← Nil ;
3- Etablir un lien de chainage entre P et Q. Q^.Suiv ← P ;
2.2- Insertion à la fin
Exemple: Soit la liste suivante {13,-5,2}, et on veut insérer X=7 à la fin
@T
@1
@1
13 @2
@2
@3-5 2
@3 Nil
1-
2-
@4 7
@P @4
3-
En ignorant les pointeurs intermédiaires P et Q, la liste de tête T sera :
A la fin du parcours (action 1), Q pointe vers le dernier élément.
@Q @1@2@3
@4 Nil

37. 37
La procédure a 2 paramètres T et X. T est passé par référence (E/S), car
la tête va changer dans le cas où elle est initialement vide.
Procédure insertion à la fin
Procedure InsertFin(E/S/ T : Pliste ; E/ X : entier);
Var P,Q : Pliste;
Debut
Allouer(P);
P^.Info ← X;
P^.Suiv ← Nil;
Si T=Nil
Alors T ← P
Sinon Q ← T; //initialiser au début
Tantque Q^.Suiv ≠ Nil Faire Q ← Q^.Suiv ; Fait; // aller à la fin
Q^.Suiv ← P; //ajouter à la fin
Fsi;
Fin;

38. 38
L’insertion d’un élément X au milieu, consiste à insérer cet élément
après un élément pointé par un pointeur Q. Une fois qu’on trouve ce Q,
l’insertion passe par les étapes suivantes:
0- Recherche de Q.
1- Créer l’élément contenant X. Allouer(P) ; P^.Info ← X;
2- Etablir un lien entre P et le suivant de Q. P^.Suiv ← Q^.Suiv ;
3- Etablir un lien de chainage entre Q et P. Q^.Suiv ← P ;
2.3- Insertion au milieu
Pour la recherche du pointeur Q qui précède le point d’insertion, on n’a
pas d’algorithme spécifique, car cette action dépend du problème posé.
Comme on l’a déjà signalé, ça peut être :
- Avant ou après une position.
- Avant ou après une valeur.
- Avant ou après une adresse.
- Vérifier une contrainte donnée, …
Donc on va s’intéresser aux actions d’insertions (1,2,3), ensuite on va
voir quelques exemple de recherche.

39. 39
Exemple
Soit une partie de la liste {...,7,13,-5,2,…}, et on veut insérer X=9 entre
13 et -5.
@5
@Q @5
13 @6
@6
@7-5 2
@7 @8
@4 7
@P @x
@5
0- Recherche Q
1- Créer X
9
@6
@x2- P^.Suiv ← Q^.Suiv
3- Q^.Suiv ← P
@x
Fin de l’opération, X=9
se trouve entre 13 et -5

40. 40
On va donner juste les actions d’insertion proprement dites, on
considère qu’on a le pointeur Q (après une recherche). Ensuite on va
donner un cas d’insertion avec un type de recherche.
Algorithme d’insertion au milieu
Algorithme InsertMilieu;
- - - -
Debut
- - -
// Actions de recherche, qui donne Q
Allouer(P);
P^.Info ← X;
P^.Suiv ← Q^.Suiv;
Q^.Suiv ← P;
- - -
Fin;

41. 41
Etant donnée une position K, cette recherche renvoie l’adresse
(pointeur) de l’élément situé à cette position. Si la position n’existe pas,
elle revoie Nil.
Exemple de recherches
Fonction AdressePos(E/ T : Pliste; E/ K : entier) : Pliste;
Var P : Pliste;
Debut
P ← T;
Tantque P ≠ Nil Et K>1
Faire P ← P^.Suiv; K ← K – 1; Fait;
AdressePos ← P;
Fin;
Recherche de l’Adresse d’une Position
Utilisation
Si on veut insérer Après une position Y : Q ← AdressePos(T,Y);
Si on veut insérer Avant une position Y : Q ← AdressePos(T,Y-1);

42. 42
Etant donnée une valeur V, cette recherche renvoie l’adresse (pointeur)
de l’élément égale à cette valeur. Si la valeur V n’existe pas, elle revoie
Nil.
Fonction AdresseVal(E/ T : Pliste; E/ V : entier) : Pliste;
Var P : Pliste;
Debut
P ← T;
Tantque P ≠ Nil Et P^.Info ≠ V
Faire P ← P^.Suiv; Fait;
AdresseVal ← P;
Fin;
Recherche de l’Adresse d’une Valeur
Utilisation
Si on veut insérer Après une valeur Val : Q ← AdresseVal(T,Val);

43. 43
Etant donnée une valeur V, cette recherche renvoie l’adresse (pointeur)
du précédent de l’élément égale à cette valeur. Si la valeur V n’existe
pas ou ne possède pas de précédent (Tête), elle revoie Nil.
Fonction AdrPreVal(E/ T : Pliste; E/ V : entier) : Pliste;
Var P,Q : Pliste;
Debut
AdrPreVal ← Nil; Q ← Nil;
Si T ≠ Nil Alors Si T^.Info ≠ V
Alors P ← T; Q ← T^.Suiv;
Tantque Q ≠ Nil Et Q^.Info ≠ V
Faire P ← Q ; Q ← Q^.Suiv; Fait
Fsi;
Si Q≠ Nil Alors AdrPreVal ← P Fsi;
Fsi;
Fin;
Recherche de l’Adresse du précédent d’une Valeur
Utilisation
Si on veut insérer Avant une valeur Val : Q ← AdrPreVal(T,Val);

44. 44
Soit T une liste d’entiers, écrire une procédure permettant d’insérer un
élément X à la position K.
Exemple d’insertion regroupant différents cas
Dans ce cas, on peut avoir les différents cas possibles (début, fin, milieu)
et même le cas d’erreur (impossible d’insérer : position n’existe pas)
Procedure Insert(E/S/ T : Pliste ; E/ X,K : entier ; S/ INS : booleen);
Var P,Q : Pliste;
Debut
Allouer(P); P^.Suiv ← X; INS ← Vrai; //créer l’élément
Si K<1
Alors INS ← Faux; //impossible d’insérer, pos n’existe pas
Sinon Si K = 1 Alors P^.Suiv ← T ; T ← P //insertion au début
Sinon Q ← AdressePos(T,K-1); //adresse du précédent de pos
Si Q = Nil
Alors INS ← Faux;
Sinon P^.Suiv ← Q^.Suiv ; Q^.Suiv ← P ; //insérer au milieu ou à la fin
Fsi;
Fsi;
Fsi;
Fsi;
Si Non INS Alors Liberer(P) Fsi; //pas d’insertion, annuler l’allocation mémoire
Fin;

45. 45
Soit T une liste d’entiers triée par ordre croissant, écrire une procédure
permettant d’insérer un élément X dans cette liste.
Exemple d’insertion dans une liste triée
Dans ce cas, l’insertion doit respecter la contrainte de l’ordre des
éléments. L’insertion est toujours possible.
Procedure Insert(E/S/ T : Pliste ; E/ X : entier ; );
Var P,Q,C : Pliste;
Debut
Allouer(P); P^.Info ← X; //créer l’élément
Si T = Nil
Alors P^.Suiv ← T ; T ← P
Sinon Si X ≤ T^.Info
Alors P^.Suiv ← T ; T ← P //insertion au début
Sinon Q ← T; C ← T^.Suiv ; //chercher la position d’insertion
Tantque C ≠ Nil Et X > C^.Info Faire Q ← C ; C ← C^.Suiv ; Fait;
P^.Suiv ← Q^.Suiv ; Q^.Suiv ← P ; //insérer au milieu ou à la fin
Fsi;
Fsi;
Fin;

46. 46
Récapitulation de l’insertion
L’insertion d’un élément X dans une liste de Tête T
Créer l’élément X Allouer(P); P^.Info ← X;
Insertion au Début
P^.Suiv ← T ; T ← P ;
Insertion à la Fin
Chercher la Fin : Q
(Q^.Suiv = Nil)
Insertion au milieu
Chercher Précédent
(Q )
P^.Suiv ← Q^.Suiv ;
Q^.Suiv ← P ;
P^.Suiv ← Nil ;
Q^.Suiv ← P ;
P^.Suiv ← Q^.Suiv ;
Q^.Suiv ← P ;
IDENTIQUE
Insertion ≠ Début

47. 47
Soit T la tête d’une liste donnée, et X un élément (partie info) à
supprimer de cette liste.
3- Suppression dans une liste chainée
Est-ce-que là aussi on peut regrouper la suppression à la fin et
la suppression au milieu ?
Oui, là aussi on peut le faire, et donc je ne vais traiter que deux cas :
début et autre que début
Comme pour l’insertion, là aussi trois cas se présentent :
1- Suppression au début.
2- Suppression à la fin.
3-Suppression au milieu.
Ce qu’il faut retenir dans la suppression
Il faut toujours chercher le précédent de X (sauf le cas du début).
Comme pour l’insertion, la recherche dépend du cas à traiter.
A la fin de la recherche on à un pointeur Q vers le précédent.

48. 48
3.1- Suppression au début
En général, la suppression consiste à détacher l’élément à supprimer en
mettant à jour le chainage, puis libérer l’espace réservé pour cet
élément.
Pour la suppression au début, on utilise un pointeur intermédiaire (P).
L’opération passe par trois étapes :
1- Sauvegarder le suivante de la tête dans P. P ← T^.Suiv ;
2- Libérer l’espace réservé pour la tête T. Liberer(T);
3- Relier la tête T à P. T ← P ;
Exemple: Soit la liste suivante {13,-5,2}, et on veut supprimer la tête (13)
@T @1
@1 13
@2
1-
2-
@P
3-
@2 @3-5 2
@3 Nil
@2@2
Fin de l’opération
13 est supprimé

49. 49
La procédure a un seul paramètre T.
T est passé par référence (E/S), car la tête va changer.
Procédure Suppression au début
Procedure SupprimeDebut(E/S/ T:Pliste);
Var P : Pliste;
Debut
Si T ≠ Nil Alors P← T^.Suiv ; Liberer(T); T ← P Fsi;
Fin;
3.2- Suppression autre que le début
Comme on l’a fait pour l’insertion, on laisse le problème de la recherche
à coté, on considère juste le résultat de cette recherche qui donne un
pointeur Q sur le précédent de l’élément à supprimer.
Soit P le pointeur sur l’élément à supprimer. L’opération passe par deux
étapes seulement:
1- Mettre à jour le suivant de Q. Q^.Suiv ← P^.Suiv ;
2- Libérer l’espace réservé pour P. Liberer(P);
Remarque
On peut aussi faire: P← T ; T ← T^.Suiv ; Liberer(P)

50. 50
Exemple
Soit une partie de la liste {...,7,13,-5,2,…}, et on veut supprimer X=-5
@Q @5
@6 -5@5 13@4 7
@5
@7 2
@8
0- Recherche Q , P
1- Mettre à jour le suivant de Q
2- Libérer l’espace de P
Fin de l’opération
-5 est supprimé @P @6
@6 @7@7
Donc dans le cas d’un algorithme, une fois qu’on à le P et le Q, les deux
actions de suppression seront:
Q^.Suiv ← P^.Suiv ;
Liberer(P);

51. 51
Soit T une liste d’entiers, écrire une procédure permettant de supprimer un
élément à la position K.
Exemple de suppression regroupant différents cas
Dans ce cas, on peut avoir les différents cas possibles (début, fin, milieu) et même
le cas d’erreur (impossible de supprimer : position n’existe pas)
Procedure Supprime(E/S/ T : Pliste ; E/ K : entier ; S/ SUP : booleen);
Var P,Q : Pliste;
Debut
SUP ← Faux;
Si T ≠ Nil
Alors SUP ← Vrai;
Si K<1
Alors SUP ← Faux; //impossible de supprimer, pos n’existe pas
Sinon Si K = 1 Alors P← T ^.Suiv ; Liberer(T); T ← P //suppression au début
Sinon Q ← AdressePos(T,K-1); //adresse du précédent de pos
Si Q = Nil Alors SUP ← Faux;
Sinon P ← Q^.Suiv ;
Q^.Suiv ← P^.Suiv ; Liberer(P) //milieu ou à la fin
Fsi;
Fsi
Fsi;
Fsi;
Fin;

52. 52
Quelques Applications courantes
Affichage des élément d’une liste
Procedure Affichage(E/ T : Pliste );
Var P : Pliste;
Debut
P ← T ;
Tantque P ≠ Nil
Faire Ecrire(P^.Info); P ← P^.Suiv ; Fait;
Fin;
Détruire une liste (supprimer tous les éléments)
Procedure Detruire(E/ T : Pliste );
Var P : Pliste;
Debut
Tantque T ≠ Nil
Faire P ← T ; T ← T^.Suiv ; Liberer(P); Fait;
Fin;

53. 53
Trier une liste
Procedure Tri(E/ T : Pliste );
Var P,Q : Pliste; X: entier;
Debut
P ← T ;
Tantque P^.Suiv ≠ Nil
Faire Q ← P^.Suiv ;
Tantque Q ≠ Nil
Faire Si Q^.Info < P^.Info
Alors X ← P^.Info ; P^.Info ← Q^.Info ; Q^.Info ← X;
Fsi;
Q ← Q^.Suiv ;
Fait;
P ← P^.Suiv ;
Fait;
Fin;

54. 54
brbessaa@gmail.com