Ch4 - Les Listes

Complexité et structures des
données
Elaboré par Mme Elkamel Hager
Jamoussi.hager@gmail.com
FSM de Monastir 2020-2021

1ere année Licence en Sciences de l’Informatique
Semestre 2
H. Jamoussi Elkamel , FSM 1
Alg Avancée
Plan du cours
Chapitre 1 : La récursivité
Chapitre 2 : Les enregistrements
Chapitre 3 : Les pointeurs
Chapitre 4 : Les Listes chainées
Chapitre 5 : Les Types Abstraits des données
Chapitre 6 : Les piles
Chapitre 7 : Les Files
Chapitre 8 : Les Arbres
Chapitre 9 : Les Arbres binaires de recherche
Chapitre 10 : Analyse et complexité des
algorithmes
Alg Avancée
1
Chapitre 4 : Les Listes Chainées

Alg Avancée
Introduction : Notion d’une liste

• La liste est la forme la plus commune d’organisation de données.
• Définition : Une liste est une suite finie, éventuellement vide,
d’éléments de même type.
• Un élément dans la liste est caractérisé par sa position (suivant,
précédent, premier, dernier, kième)
• Notation : L = <e1, e2, e3,…, en>

On dit que : e2 succède l’élément e1 et précède l’élément e3.
e1 est le premier élément
en est le dernier élément
• Exemple : Liste d’entiers L = <10, 2, 37, 4>
Liste de personnes L= <Ali, Mohamed, Salah, Aya>
Alg Avancée
2
Les opérations sur une Liste
• Pour manipuler une Liste il faut définir un
ensemble d’opérations.
• Ces opérations doivent être minimales tout en
étant suffisantes pour permettre de manipuler la
Liste.
• Ces opérations sont de deux types
– les Observateurs
– les Constructeurs.

Alg Avancée
Les opérations sur une Liste
• Les observateurs (méthodes d’accès Access Methods)

• informe sur l’état de la Liste sans la modifier
• exemple: tester si la liste est vide
• Les constructeurs
Les constructeurs permettent
• Soit la création d’une nouvelle Liste
• Soit la modification d’une Liste existante sans pour autant
retourner des informations à propos de la Liste
Remarque : Une opération est soit un observateur, soit un
constructeur, mais jamais les deux en même temps.

Alg Avancée
3
Les conditions sur une opération
• Une opération est considérée comme une fonction totale ou
une fonction partielle dont la restriction s’exprime par des
conditions d’applications qu’on doit spécifier
• Ces conditions sont :
• Pré conditions: conditions supposées êtres vraies quand on fait
appel à une opération.
• Exemple: supprimer un élément d’une liste
pré conditions: la liste n’est pas vide
• les pré conditions d’une opération ne doivent jamais être vérifiées à
l’intérieur de celle-ci, mais par la méthode appelante.
• Post conditions: conditions supposées êtres vraies après appel à
une opération.
• Exemple: insérer un élément dans une liste
post conditions: la liste n’est pas vide
• les observateurs ne font aucune modification des objets, donc n’admettent
pas de post conditions.

Alg Avancée
Type Abstrait des Données Liste

• Type Liste
Paramètres : Elément
Utilise : Booléen, Position
Opérations :
constructeurs
créerListe :  Liste
• Post condition: la liste est crée et elle est vide
insérer : Elément  Position  Liste Liste
• Insère un élément à une position donnée. Dépendamment de la stratégie, on peut
développer d’autres opérations spécifiques d’insertion: fin, début, ..
• Pré conditions: position valide
• Post condition: la liste ne pas vide
supprimer : Position  Liste Liste
• Supprime un élément dans une position donnée.
• Pré conditions: Liste non vide et position valide
modifier : Elément  Position  Liste Liste
• Remplace l’élément se trouvant dans une position donnée par un autre
• Pré conditions: Liste non vide et position valide
Alg Avancée
4
TAD Liste
observateurs
estVide : Liste  Booléen
• Détermine si la liste est vide ou non
premier : Liste  Position
• Renvoie la position du premier élément.
• Pré conditions: Liste non vide
Dernier : Liste  Position
• Renvoie la position du dernier élément.
elt : Liste  Position  Elément
• Renvoie l’élément se trouvant dans une position
donnée.
• Pré conditions: Liste non vide, position valide.
Alg Avancée
TAD Liste
Suivant : Liste  Position  Position
• Donne la position suivante.
• Pré conditions: La liste n’est pas vide, la position est
valide et on n’est pas à la fin de la liste
précédent : Liste  Position  Position

• Donne la position précédente.
• Pré conditions: La liste n’est pas vide, la position est
valide et on n’est pas au début de la liste

Alg Avancée
5
Implémentation d’une Liste
Pour implémenter une liste on utilise une structure des données.
• Une structure des données est un ensemble des cellules de

mémoire qui sont reliées d’une certaine façon et qui peuvent
contenir chacune une valeur. Toutes ces valeurs étant de même
type.
Deux implémentations possibles
• L’implémentation Statique :
en utilisant les tableaux
• L’implémentation Dynamique :
en utilisant les listes chaînées qui peuvent être:
Les listes simplement chaînées
Les listes doublement chainées
Les listes Circulaires
Les listes quelconques
Alg Avancée
Implémentation statique d’une Liste

• L’implémentation Statique : signifie qu’au chargement du
programme, à l’exécution, la réservation des variables est effectuée
et ces variables ne changent pas de place par rapport à l’espace
mémoire du programme.
L’implémentation statique d’une liste peut se faire à l’aide d’un

tableau.
– Un tableau est un espace des cases mémoires qui sont contigües.

– Pour accéder à l’élément suivant dans un tableau, il suffit
d’incrémenter l’indice d’un pas

Alg Avancée
6
Implémentation Tableau d’une Liste
Avantages
• L’accès à un élément est direct
• L’accès est rapide
Inconvénients
• La Suppression et l’insertion nécessite généralement un décalage
(pour insérer un élément dans un tableau T à la kème position, il faut
tout d’abord déplacer tous les éléments du tableau de la kème position
jusqu’au dernier élément, ensuite placer l’élément à intercaler à la
kème position).
• Espace de taille fixe:
o Perte d’espace
o Manque d’espace.
• occupation inutile de l’espace mémoire pendant l’exécution
Alg Avancée
Implémentation dynamique d’une Liste

• L’implémentation Dynamique : les réservations et libérations des
variables s’effectuent en cours d’exécution en utilisant les pointeurs.
• Avantages : optimisation de l’espace mémoire occupé
• Inconvénients : l’efficacité est diminuée par la gestion de la
mémoire qui se fait en cours d’exécution.
L’implémentation dynamique d’une liste peut se faire à l’aide d’une
liste chainée.
– Une liste chainée est un ensemble des cases éparpillées dans la
mémoire qui sont reliées l’une à l’autre.
– Pour accéder à l’élément suivant dans une liste, il faut connaître
l’adresse de la case suivante.
– Une cellule dans une liste chainée contient deux champs:
• Un champs qui contient la valeur de l’élément
• Un champs qui donne l’adresse de la cellule contenant
l’élément suivant
– La liste est identifiée par sa tête 14
Alg Avancée H. Jamoussi Elkamel , FSM
7
Implémentation dynamique d’une Liste
Avantages
• L’avantage d’une liste chaînée par rapport à un tableau est sa
souplesse : on peut l’agrandir, intercaler des objets et diminuer sa
taille, avec un minimum d’opérations.
• L’insertion et la suppression d’un élément dans une liste chaînée
sont réalisées sans le recours au décalage des éléments
Inconvénients
• L’accès à un élément est un accès séquentiel. Pour accéder à
l’élément à la kème position, il faut parcourir la liste depuis le début
jusqu'à atteindre la kème position.

Alg Avancée
Liste simplement chainée

Alg Avancée
8
Une liste simplement chaînée étant une succession de cellules (nœuds) tel
que :
– les cellules sont chainées (liées) entre elles en utilisant les pointeurs
Exemple L=<25, 3, 10, 15 > une liste de 4 entiers
25  3  10  15 /
Tête
– Chaque cellule dans une liste simplement chainée contient deux
champs:
• Un champs qui contient la valeur de l’élément c’est l’information à
traiter
• Un champs qui donne l’adresse de la cellule contenant l’élément
suivant c’est un pointeur vers la cellule suivante.
Valeur de L’adresse de la cellule
l’élément contenant l’élément suivant
25 
Alg Avancée
25  3  10  15 /
Tête
– La liste est identifiée par sa tête qui est le pointeur sur la première
cellule.
– La perte de la tête de la liste conduit à la perte de la liste
– La dernière cellule n’a pas de suivant elle pointe vers l’adresse
invalide (nil ) représentée par / .
– Le principal problème des listes simplement chaînées est l'absence de
pointeur sur l'élément précédent du maillon, il est donc possible de
parcourir la chaîne uniquement du début vers la fin.
– Une liste vide est réduite au pointeur nil ( tete = nil)
Alg Avancée
9
Déclaration
A  B  C  D /
Tête
Type
Cellule = Enregistrement
Val Suiv
val: Elément B 
Suiv : ^Cellule
FinCellule p
Position = ^Cellule /* une position dans la liste est l’adresse d’une cellule*/
Liste = ^Cellule /*une liste est identifiée par l’adresse de la première cellule*/
Var
Tete : liste
P : position
Alg Avancée
Déclaration
25  10  34  15 /
Tête queue
Type
val: entier
Suiv : ^Cellule
FinCellule
Position = ^Cellule
Liste = ^Cellule

Alg Avancée
10
Déclaration
Pour définir une liste simplement chaînée d’étudiants il suffit d’écrire
Type NCE nom prenom age suiv
CelluleEtudiant = Enregistrement
NCE : chaine[5] 
nom, prénom : chaîne[25]
Age : entier
Suiv : ^CelluleEtudiant
FinCelluleEtudiant
Position = ^CelluleEtudiant
Liste = ^CelluleEtudiant
5416 Ben ali Mohamed 20  0416 Kilani Aya 21 

Tête
5416 Ben salah Salah 20  5416 Bhouri Emna 22 

Alg Avancée
Accès à la liste chaînée

Type Var
Cellule = Enregistrement Tete : liste
val : Elément P : position
Suiv : ^Cellule
FinCellule
Position = ^Cellule
Liste = ^Cellule
Val suiv Val suiv Val suiv Val suiv
A  B  C  D /
Tête
Tête^ (Tête^.suiv)^
Tête^.val Tête^.suiv
Alg Avancée
11
Début et fin de la liste
25  10  34  15 /
Tête queue
• Deux positions sont très importantes dans une liste chainée : le début
et la fin, souvent désignées par "premier et dernier" ou "tête et queue".
• Sans le tête impossible de savoir où commence la liste chainée et sans
la queue impossible de savoir où elle s'arrête.
• Si la liste est vide la tête et la queue sont nil
• Si la liste n’est pas vide
o La tête est donnée par l'adresse de la première cellule
o La queue est donnée par l’adresse de la dernière cellule dans la liste, elle est
définie par ( queue^.suiv = nil )
Alg Avancée

estVide : Liste  Booléen
• Détermine si la liste est vide ou non
Problème estVide
o Entrées : tete : liste
o Sorties: booleen = vrai si la liste est vide faux sinon
// une liste est vide si sa tete est nil
Fonction estvide (tete : Liste) : booleen

Début
Retourner(tete = nil)
Fin

Alg Avancée
12
premier : Liste  Position
• Renvoie la position du premier élément.
Fonction premier (tete :Liste) : Position

Début
Retourner(tete )
Fin

Alg Avancée

Dernier : Liste  Position
• Renvoie la position du dernier élément .
Fonction dernier(tete : Liste): position
Remarque
Var p : position Le dernier est tel que
Début son suivant est nil
ptete
Condition d’arrêt
TantQue ( p^.suiv < > nil) faire
p^.suiv = nil
p p^.suiv
donc P est la
FinTantQue dernière position
retourner(p) dans la liste
Fin
Alg Avancée
13
Parcours d’une liste chaînée
C'est l'opération de base sur les listes :
• on va du début à la fin de la liste
• à chaque cellule on fait une opération qui utilise sa donnée.
On a seulement un schéma d'algorithme, parce qu'il y a plusieurs
variantes selon le traitement. Quelques exemples de traitement
• Afficher toutes les données à l'écran,
• renvoyer la somme ou la moyenne des données,
• renvoyer la liste des données supérieures à 3.
Pour parcourir une liste chainée il suffit avec un pointeur de prendre
successivement l'adresse de chaque maillon. Au départ le pointeur prend
l'adresse du premier élément qui est la tête de la liste, ensuite il prend
l'adresse du la cellule suivante et ainsi de suite jusqu’à terminer la liste .

Alg Avancée
Parcours d’une liste chaînée
Pour parcourir les éléments de la liste chaînée, nous avons besoin de :

• Initialiser la position du parcours à la tête de la liste p← tete
• Traiter l’ Elément courant p^.val
• avancer à la position suivante p ← p^.suiv
• S’arrêter si on détecte la Fin de la liste p = NIL

Alg Avancée
14
Schéma d’un algorithme de Parcours
Type
Problème parcours Cellule = Enregistrement
o Entrées : tete : Liste des éléments val : element
o Sortie : le type de valeur de retour Suiv : ^Cellule
dépend du traitement FinCellule
Position = ^Cellule
Procedure parcours ( Tete : Liste) Liste = ^Cellule
Var p : position
Début
ptete
Initialisation traitement
TantQue ( p < > nil) faire
traiter p^.val
p p^.suiv
FinTantQue
terminaison traitement
Fin
Alg Avancée
Affichage des éléments d’une liste

Type
Problème Afficher-Elements Cellule = Enregistrement
o Entrées : tete : Liste des entiers val: entier
Suiv : ^Cellule
o Sortie : affichage des éléments
FinCellule
Position = ^Cellule
Liste = ^Cellule
Procedure Afficher-Elements ( Tete : Liste)
Var p : position
Début
ptete
ecrire( p^.val)
p p^.suiv
FinTantQue
Fin
Alg Avancée
15
Calcul somme des éléments d’une liste
Type Cellule = Enregistrement
Problème Somme-Elements val : entier
Suiv : ^Cellule
o Entrées : tete : Liste des entiers
FinCellule
o Sortie : S: entier somme des éléments Position = ^Cellule
Liste = ^Cellule
Fonction Somme-Elements ( Tete : Liste): entier
Var p : position
S: entier
Début
ptete
S0
SS+ p^.val
p p^.suiv
FinTantQue
Retourner(S)
Fin
Alg Avancée H. Jamoussi Elkamel , FSM 31
Calcul longueur d’une liste

Type Cellule = Enregistrement
Problème longueur val : entier
Suiv : ^Cellule
FinCellule
o Sortie : long: entier longueur de la liste Position = ^Cellule
Liste = ^Cellule
Fonction Somme-Elements ( Tete : Liste): entier
Var p : position
long: entier
Début
ptete
long0
longlong + 1
p p^.suiv
FinTantQue
Retourner(long)
Fin
16
Recherche d’un éléments
Type
Problème Trouver-Elem
val: entier
E: entier Suiv : ^Cellule
o Sortie : p: position de e dans la liste FinCellule
tete s’il existe, nil sinon Position = ^Cellule
Liste = ^Cellule
On commence le parcours de la liste à partir de la tête (la première

position dans la liste) on s’arrête si
o On termine la liste : p = nil
Ou
o on trouve l’élément dans la cellule de position p : p^.val = E

Alg Avancée
Type
Recherche d’un éléments
val: entier
Suiv : ^Cellule
FinCellule
Position = ^Cellule
Liste = ^Cellule
Procedure Trouver-Elem ( E: entier, Tete : Liste) : position
Var p : position
Début
ptete
TantQue ( p < > nil) et (p^.val < > E) faire
p p^.suiv
FinTantQue
// si p = nil : E non trouvé dans la liste
// si p ≠ nil : E se trouve dans la position P
retourner(p)
Alg Avancée Fin H. Jamoussi Elkamel , FSM 34
17
Les opérations de modification d’une liste chainée
La liste représentant un ensemble d’éléments organisés en
séquence, nous retrouvons les opérations habituelles
associées :
 Création d’une liste vide

 Ajout d’une cellule
 Suppression d’une cellule
 Modification d’une cellule
Création d’une liste vide

Problème Créer-Liste : Permet de créer une liste vite
créerListe :  Liste
• Post condition: la liste est crée et elle est vide
La manière la plus simple d’initialiser une liste identifiée par la
variable tête est de mettre celle-ci à nil
Procedure Créer-Liste (var tete : Liste)

Début
tetenil
Fin

Alg Avancée
18
Ajout d’un élément en tête
Problème Inserer-tete : Permet d’insérer un élément en entête de la liste
Insérer-tete : Elément  Liste Liste

• Insère un élément E à tête de la liste.
• Post condition: la liste n’est pas vide et l’élément est en tête de la liste
Tête
 25  10  34  15 /
4
3
1
 1 Créer une nouvelle cellule pointé par p
E 2 
p 2 Initialiser le champ val avec l’élément E
val suiv
3 Chainer la cellule à la liste
4 Changer la tête
Alg Avancée

• Post condition: la liste ne pas vide et l’élément est en tête de la liste
Tête
 25  10  34  15 /
4
3
1
 E 2 
p val suiv
1 Créer une nouvelle cellule pointé par p allouer(p)

2 Initialiser le champ val avec l’élément E p^.val← E
3 Chainer la cellule à la liste p^.suiv← tete
4 Changer la tête tete ← p
Alg Avancée
19
Tête Insérer-tete : Elément  Liste Liste
 25  10  34  15 /
4
3
1 Le cas où tete =NIL (liste vide)
 E 2  entre dans le cas général :
p p^.suiv prend la valeur NIL
val suiv
Procedure inserer-tete (var tete: Liste; E: element)
var p: position
Début
allouer(p)
p^.val← E
p^.suiv← tete
tete ← p
Alg Avancée
Fin H. Jamoussi Elkamel , FSM 39
Ajout d’un élément après une position q

Problème Inserer-après : Permet d’insérer un élément E dans
une liste après une position q
Insérer-après : Elément  position  Liste Liste

• Insère un élément E après la position q dans la liste.
• Prés condition : la liste n’est pas vide
la position q est une position dans la liste
• Post condition: la liste n’est pas vide
Deux cas possibles :

• q est la position de la dernière cellule : insertion en queue
• q est une position entre deux cellules : insertion au milieu

Alg Avancée
20
ajout au milieu après une position q
Tête suiv
 25  10  34  15 /
4 3
1
q   E 2 
p val suiv
3 Chainer la cellule à la liste après le q p^.suiv← q^.suiv
4 Détourner le chaînage q^.suiv← p
Alg Avancée
ajout en queue
• Le cas où q pointe sur la dernière cellule de la liste entre dans le cas
général : p^.suiv prend la valeur NIL ( q^.suiv = nil)
suiv
Tête
 25  10  34  15 /
4
1
q  p E 2 /3
val suiv
3 Définir la cellule p comme dernière cellule p^.suiv← nil
// p^.suiv← q^.suiv
4 chaînage de la cellule p à la suite de q q^.suiv← p
Alg Avancée
21
Insérer-apres : Elément  position  Liste Liste
Tête suiv
 25  10  34  15 /
l'insertion à la fin ou 4 3
au milieu c'est le 1
q
même travail, ce   E 2 
n'est pas la peine de p val suiv
traiter chaque cas à
part Procedure inserer-apres (var tete: Liste; q: position E: élément)
var p: position
Début
allouer(p)
p^.val← E
p^.suiv← q^.suiv // si insertion en queue q^.suiv = nil
q^.suiv ← p
Alg Avancée
Fin
Insérer un élément
problème Inserer : Permet d’insérer un élément E dans une
liste
Le fait d'insérer plutôt qu'ajouter un élément dans la liste

suppose un classement. Il faut un critère d'insertion,
pourquoi ici et pas là ?
Trois cas sont possibles :

• la liste est vide,
• insérer au début avant le premier,
• chercher la place précédente et insérer après.

Alg Avancée
22
Insérer un élément comme kième élément
Problème Inserer-kième : Permet d’insérer un élément E
dans une liste comme kième élément
Insérer-kième : Elément  entier  Liste Liste

• Insère un élément E comme k ième élément.
• Prés condition : 1 ≤ k ≤ longueur(tete)
Si la liste est vide alors insertion en entête

Sinon si (k = 1 ) alors insertion entête
sinon chercher la position précédente de (k-1)ième élément
et insérer après.

Alg Avancée
Insérer un élément comme kième élément( 1iere proposition)

Procédure insérer-kième (E: élément; k: entier ; var tete :Liste)
Var qpred, p : position
Début
// créer et initialiser une nouvelle cellule
Allouer(p)
P^.valE
P^.suiv  Nil
Si (tete= nil) ou (k=1) Alors //Insertion en tête
P^.suiv  tete
tete  P
Sinon // recherche la position du prédécesseur et insertion après
qpred tete
Pour i de 2 à (k -1) faire
qpred  qpred^.suiv
FinPour
p^.suiv  qpred^.suiv
qpred^.suiv p
FinSi 46
Fin
23
Insérer un élément comme kième élément( 2ième proposition)
Procédure insérer-kième (E: élément; k: entier ; var tete : Liste)
Début
Si estVide(tete) ou (k=1) Alors //Insertion en tête
Insérer-tete(E, tete)
qpred tete
FinPour
Insérer-apres(E, qpred, tete)

FinSi
Fin

Alg Avancée
Insérer un élément dans une liste triée

Problème Inserer-triée : Permet d’insérer un élément E dans
une liste triée par ordre croissant
Insérer-triée : Elément  Liste Liste

• Insère un élément dans une liste triée par ordre croissant.
• Prés condition : la liste est vide ou elle est triée par ordre
croissant
• Post condition: la liste n’est pas vide est triée par ordre
croissant
Si la liste est vide alors insertion en entête
Sinon si (la nouvelle valeur est inférieure à celle de la première
cellule ) alors insertion entête
sinon il faut chercher la bonne place et conserver
l'adresse de la cellule qui précède et insérer après.

Alg Avancée
24
Exemple insérer l’élément 18 dans la séquence <5, 10, 24, 45>
1. Créer une nouvelle cellule P et y ranger 18
Tête
 5  10  24  45 /
 18 /
p val suiv
Alg Avancée

2. Repérer la position d’insertion :
ppred : l’adresse de la cellule qui précède l’élément inséré,
pc : l’adresse de la cellule qui le suit
Tête suiv
 5  10  24  45 /
 
qpred qc
 18 /
p val suiv
Alg Avancée
25
Pour trouver la cellule précédente à celle de l’élément à insérer, la liste
est parcourue tant que nous n’avons pas atteint la fin de la liste et que la
valeur de l’élément à insérer E est supérieure a la valeur de l’élément
courant.
Nous avons besoin de deux pointeurs :
• un pour l’élément courant : qc
• et un pour l‘élément précedent : qpred
A chaque tour, avant d'avancer l’élément courant d’une cellule, l'adresse
de l’élément précèdent est sauvegardée :
au départ
• qc est initialisé à la tête
• qpred est initialisé à nil

Alg Avancée

3. Accrocher p à la liste : déterminer la valeur du successeur de p :
l’ancien successeur de qpred c’est qc
Tête suiv
 5  10  24  45 /
 
qpred qc
 18 
p val suiv
Alg Avancée
26
4. Détourner le chaînage: déterminer la valeur du successeur de qpred
c’est le p
Tête suiv
 5  10  24  45 /
 
qpred qc
 18 
p val suiv
Alg Avancée
Insérer un élément dans une liste triée( 1iere proposition)

Procédure insérer-triée (E: élément; var tete :Liste)
Var qpred, qc, p : position
Début // créer et initialiser une nouvelle cellule
Allouer(p)
P^.valE
P^.suiv  Nil
Si (tete= nil) ou (E < tete^.val ) Alors //Insertion en tête
P^.suiv  tete
tete  P
qc tete qpred  nil
tant que (qc <> nil ) et ( E > qc^.suiv ) faire
qpred  qc
qc  qc^.suiv
FinTantque
// qc = NIL ou qc^.val ≥ E : on place E avant qc donc après qpred
p^.suiv  qc // qc = qpred^.suiv
qpred^.suiv p
Alg Avancée FinSi H. Jamoussi Elkamel , FSM 54
Fin
27
Insérer un élément dans une liste triée ( 2ième proposition)
Procédure insérer-triée (E: élément; var tete :Liste)
Var qpred, qc, p : position
Début
Si (tete= nil) ou (E < tete^.val ) Alors //Insertion en tête
inserer-tete(E, tete)
qc tete
qpred  qc
qc  qc^.suiv
FinTantque
// qc = NIL ou qc^.val ≥ E : on place E avant qc donc après qpred
inserer-après(E, qpred, tete)
FinSi
Fin
Alg Avancée
Suppression d’un élément en tête

Problème supprimer-tete : Permet supprimer un élément en tête de la
liste
Supprimer-tete : Liste Liste
• Supprime la cellule qui se trouve en tête de la liste.
• Pres- condition: la liste n’est pas vide
2
Tête
 25  10  34  15 /
1 3
 1 Sauvegarder la tête dans p p ← tête

p 2 Changer la tête vers la cellule suivante tete ← tete^.suiv
3 Détruire la cellule libérer(p)
4 Réinitialiser p à nil p ← nil
Alg Avancée
28
• Supprime la cellule qui se trouve en entête de la liste.
2
Tête
 25  10  34  15 /
1 3 Procedure supprimer-tete (var tete : Liste)
var p: position
 Début
p p ← tete
Le cas: la liste contient un tete ← tete^.suiv
seul élément (tete^.suiv= nil) liberer(p)
entre dans le cas général: p← nil
après la suppression la liste Fin
dévient vide (tete= nil).

Alg Avancée
Suppression d’un élément après une position q
Problème Supprimer-après : Permet de supprimer l’élément

successeur de q
Supprimer-après : Position  Liste Liste

• Supprime l’élément successeur de q.

• Le successeur de q est la position de la dernière cellule :
suppression en queue
• Le successeur de q est une position entre deux cellules :
suppression au milieu

Alg Avancée
29
Suppression au milieu après une position q
supprimer-après : position  Liste Liste
Tête suiv 2 suiv

 25  10  34  15 /
3
1
q  p 
1 Sauvegarder l’adresse de la cellule à supprimer p ←q^.suiv
2 Changer le chaînage q^.suiv ← p^.suiv
3 Détruire la cellule liberer(p)
4 Réinitialiser p à nil p← nil
Alg Avancée
Suppression en queue après une position q

• Le cas où q pointe l’avant dernière cellule (suppression de la dernière
cellule) entre dans le cas général : q^.suiv prend la valeur NIL
Tête suiv 2 suiv

 25  10 / 34 /
3
1
q  p 
1 Sauvegarder l’adresse de la cellule à supprimer p ←q^.suiv
2 Changer le suivant de q q^.suiv ← nil
// q^.suiv ← p^.suiv
4 Réinitialiser p à nil p← nil
Alg Avancée
30
Suppression d’un élément après une position q
Supprimer-apres : position  Liste Liste
Tête suiv 2 suiv
 25  10  34  15 /
3
La suppression à la fin ou au
1
milieu c'est le même travail, q 
ce n'est pas la peine de traiter p 
chaque cas à part
Procedure Supprimer-apres (var tete: Liste; q : position )
var p: position
Début
p ←q^.suiv
q^.suiv← p^.suiv // si suppression en queue p^.suiv = nil
liberer(p)
p← nil
Alg Avancée Fin H. Jamoussi Elkamel , FSM 61
Suppression d’un élément

problème supprimer : Permet de supprimer un élément E
dans une liste
Le fait de supprimer un élément dans une liste nécessite la

recherche de l’élément et de repérer son prédécesseur
Deux cas sont possibles :

• L’élément est en entête => suppression en entête,
• L’élément est au milieu ou la fin => suppression après son
prédécesseur

Alg Avancée
31
Supprimer kième élément
Problème Supprimer-kième : Permet de supprimer kième
élément de la liste.
Supprimer-kième : entier  Liste Liste

• Supprimer kième élément.
• Prés condition : 1 ≤ k ≤ longueur(tete)
la liste n’est pas vide
si (k = 1 ) alors suppression entête

sinon chercher la position de prédécesseur de kième élément
et supprimer après.

Alg Avancée
Supprimer kième élément( 1iere proposition)

Procédure Supprimer-kième (k: entier ; var tete :Liste)
Début
Si (k=1) Alors //suppression en entête
P tete
tete  tete^.suiv
Sinon // recherche la position du prédécesseur et suppression après
qpred tete
FinPour
p  qpred^.suiv
qpred^.suiv p^.suiv
FinSi
liberer(p)
p nil
Alg Avancée
Fin H. Jamoussi Elkamel , FSM 64
32
Supprimer kième élément( 2iere proposition)

Procédure Supprimer-kième (k: entier ; var tete :Liste)
Début
Si (k=1) Alors //suppression en entête
supprimer-tete(tete)
Sinon // recherche la position du prédécesseur et suppression après
qpred tete
FinPour
Supprimer-apres(tete, qpred)
FinSi
Fin

Alg Avancée
Supprimer un élément dans une liste triée

Problème Supprimer-triée : Permet de supprimer un élément
E d’une liste triée par ordre croissant
Supprimer-triée : Elément  Liste Liste
• Supprimer un élément dans une liste triée par ordre croissant.
• Prés condition : la liste est vide ou elle est triée par ordre
croissant
• Post condition: la liste est triée par ordre croissant
Si la liste est vide
alors rien faire
Sinon recherche de l’élément
s’il existe dans la première cellule
alors suppression entête
sinon s’il existe au milieu ou à la fin de la liste
alors suppression après
sinon rien faire
Alg Avancée
33
Exemple: supprimer 24 de la séquence <5, 10, 24, 45, 56>
1. Déterminer l’adresse qc de la cellule à supprimer et l’adresse

de son prédécesseur qpred:
Tête suiv
 5  10  24  45  56 /
 
qpred qc

Alg Avancée

2. Détourner le chaînage: qpred^.suiv  qc^.suiv
Tête suiv suiv

 5  10  24  45  56 /
 
qpred qc

Alg Avancée
34
3. Détruire la cellule pointée par qc libérer (qc)
Tête suiv
 5  10  45  56 /
 
qpred qc

Alg Avancée
Supprimer un élément dans une liste triée( 1iere proposition)

supprimer-triée : Elément  Liste Liste
Procedure supprimer-triée (E: élément; var tete :Liste)
Var qpred, qc : position
Début
Si (tete < > nil) alors
// recherche de la position qc de l’élément à supprimer et de son
// prédécesseur qpred
qc tete
qpred  nil
qpred  qc
qc  qc^.suiv
FinTantque
// qc = NIL ou qc^.val ≥ E

Alg Avancée
35
Supprimer un élément dans une liste triée( 1iere proposition)

Si (qc < > nil) et (E = qc^.val )
Alors //l’élément E existe dans la liste dans la position qc
Si (qpred = nil)
Alors //l’élément E existe dans la tete de la liste
tete  tete^.suiv
Sinon // l’élément existe au milieu ou à la fin de la liste
qpred^.suiv qc^.suiv
Finsi
liberer(qc)
qc← nil
Finsi
FinSi
Fin
Alg Avancée
Supprimer un élément dans une liste triée( 2ième proposition)

Procedure supprimer-triée (E: élément; var tete :Liste)
Var qpred, qc : position
Début
Si (tete < > nil) alors
// recherche de la position qc de l’élément à supprimer et de son prédécesseur qpred
qc tete
qpred  nil
qpred  qc
qc  qc^.suiv
FinTantque
Si (qc < > nil) et (E = qc^.val )
Alors //l’élément E existe dans la liste dans la position qc
Si (qpred = nil)
Alors //l’élément E existe dans tete de la liste
Supprimer-tete(tete)
Sinon // l’élément existe au milieu ou à la fin de la liste
Supprimer-apres(tete, qpred)
Finsi
Finsi
FinSi
36
Les algorithmes récursifs de
manipulation d’une liste simplement
chainée

Alg Avancée
Définition récursive d’une liste simplement chainée

la vision récursive définit une liste par son premier élément. celui ci
pointe vers la liste des éléments suivants
une liste est :
• soit une liste vide ( nil )
• soit un élément en entête (tête^.val) suivi d'une liste (tête^.suiv)
Reste de la liste de tête Tête^.suiv

Tête val suiv
 5  10  204  45  6 /
 Tête^.suiv
Alg Avancée
37
Algorithmes récursifs de manipulation d’une liste
• Une liste n’a que deux états : vide (nil) ou non vide ( non nil)
• Les algorithmes récursifs de manipulation d’une liste chaînée auront
un cas de base qui contiendra l’état nil
Les algorithmes récursifs
 cas de Base : la liste vide : tête = NIL
 le processus de Récurrence : tête pointe sur une cellule composée :
o d’un élément (tete^.val) premier élément de la liste
o d’une Adresse (tete^.suiv) représentant la tête du reste de la liste qui suit le
premier élément
• Les algorithmes récursifs comporteront donc toujours un paramètre
de plus (modifié) : la tête de la liste sur laquelle porte l’opération.

Alg Avancée
Algorithme récursif de parcours dans une liste

Problème parcours-Rec : Permet de parcourir une liste
parcours-Rec : Liste ?
• Parcourir une liste pour faire un traitement
• Le résultat dépend de traitement à faire
Cas de base
1. La liste vide (tete = nil ) => traitement particulier
Processus récursif
si la liste n’est pas vide (tete < > nil )
• Traiter l’élément qui est en entête
• et poursuivre le parcours récursif du reste de la liste .

Alg Avancée
38
Algorithme récursif de calcul de la longueur de la liste
Problème longueur-Rec : Permet de calculer la longueur

une liste
Longueuer-Rec : Liste entier
• Calcul la longueur d’une liste
Cas de base
1. La liste vide (tete = nil ) => longueur est 0
Processus récursif
• Longueur = 1 ( l’élément qui est en entête ) + longueur du reste de la
liste .

Alg Avancée
Algorithme récursif de calcul de la longueur de la liste
longueur-Rec : Liste entier
Fonction longueur-Rec (tete :Liste) : entier

Début
Si (tete= nil)
Alors retourner(0)
Sinon retourner( 1+ longueur-Rec ( tete^.suiv ) )
FinSi
Fin

Alg Avancée
39
Algorithme récursif de calcul de la somme des éléments d’une liste
Problème Somme-Rec : Permet de calculer la somme des

éléments d’une liste
Somme-Rec : Liste entier
• Calcul la longueur d’une liste
Cas de base
1. La liste vide (tete = nil ) => somme est 0
Processus récursif
• Somme = valeur de l’élément qui est en entête + longueur du reste de
la liste .

Alg Avancée
Algorithme récursif de calcul de la somme des éléments d’une liste
somme-Rec : Liste entier
Fonction Somme-Rec (tete :Liste) : entier

Début
Si (tete= nil)
Alors retourner(0)
Sinon retourner( tete^.val + longueur-Rec ( tete^.suiv ) )
FinSi
Fin

Alg Avancée
40
Algorithme récursif de recherche dans une liste triée
Problème Recherche-triée-Rec : Permet de rechercher un
élément E dans une liste triée par ordre croissant
recherche-triée-Rec : Elément  Liste Position

• Recherche un élément dans une liste triée par ordre croissant.
• Post condition: la position est égale à nil si l’élément n’existe pas dans la
liste, sinon c’est la position de l’élément dans liste
Cas de base
1. La liste vide (tete = nil ) => l’élément n’existe pas
2. La liste n’est pas vide et l’élément e est égale à celui de la première
cellule (e = tete^.val) => l’élément existe dans la position tête
3. La liste n’est pas vide et l’élément e est inférieur à celui de la
première cellule (e < tete^.val) => l’élément n’existe pas
Processus recursif
La liste n’est pas vide et l’élément e est supérieur à celui de la première
cellule (e > tete^.val) => recherche récursive dans le reste de la liste .

Alg Avancée

Exemple: soit la séquence <5, 10, 24, 45>
1. Recherche de l’élément 3 dans la séquence (3<5)=> 3 n’existe pas

2. Recherche de l’élément 5 dans la séquence (5 = 5)=> 5 existe en
entête
3. Recherche de l’élément 24 dans la séquence (24 >5)=> recherche
récursive de 24 dans le reste de la liste de tête tête^.suiv
Tête suiv
 5  10  24  45 /
 Tête^.suiv
Alg Avancée
41
Recherche-triée-Rec : Elément  Liste position
Fonction recherche-triée-Rec (E: élément; tete :Liste) : position

Début
Si (tete= nil) ou (E < tete^.val )
Alors retourner(nil)
Sinon Si (E = tete^.val )
Alors retourner(tete)
Sinon
retourner( recherche-triée-Rec (E, tete^.suiv ) )
FinSi
FinSi
Fin

Alg Avancée
Algorithme récursif d’insertion dans une liste triée

Problème Inserer-triée-Rec : Permet d’insérer un élément E
dans une liste triée par ordre croissant
Insérer-triée-Rec : Elément  Liste Liste

• Insère un élément dans une liste triée par ordre croissant.
• Prés condition : la liste est vide ou elle est triée par ordre croissant
• Post condition: la liste n’est pas vide est triée par ordre croissant
Cas de base
1. La liste vide => insertion en entête
2. La liste n’est pas vide et la nouvelle valeur est égale à celle de la
première cellule (e = tete^.val) => l’élément existe déjà
3. La liste n’est pas vide et la nouvelle valeur est inférieure à celle de la
première cellule (e < tete^.val) => insertion en entête
Processus recursif
La liste n’est pas vide et la nouvelle valeur est supérieure à celle de la première
cellule (e > tete^.val) => insertion récursive dans le reste de la liste .

Alg Avancée
42
1. insérer l’élément 3 dans la séquence (3<5)=> insertion en entête

3. insérer l’élément 18 dans la séquence (18 > 5) => insertion
récursive dans le reste de la liste de tête tête^.suiv
Tête suiv
 5  10  24  45 /
 Tête^.suiv

Alg Avancée

(1iere proposition)
Procédure insérer-triée-Rec (E: élément; var tete :Liste)
Var p : position
Alors //Insertion en tête
Allouer(p)
P^.valE
P^.suiv  tete
tete  P
Sinon Si (E > tete^.val )
Alors // insertion récursive dans le reste de la liste
insérer-triée-Rec (E, tete^.suiv )
FinSi
FinSi
Fin
Alg Avancée
43
(2iere proposition)
Procédure insérer-triée-Rec (E: élément; var tete :Liste)

Var p : position
Alors //Insertion en tête
inserer-tete(tete)

Alors // insertion récursive dans le reste de la liste
insérer-triée-Rec (E, tete^.suiv )
FinSi
FinSi
Fin
Alg Avancée
Algorithme récursif de suppression dans une liste triée
Problème supprimer-triée-Rec : Permet de supprimer un

élément E dans une liste triée par ordre croissant
supprimer-triée-Rec : Elément  Liste Liste

• supprime un élément dans une liste triée par ordre croissant.
• Prés condition : la liste est vide ou elle est triée par ordre croissant
• Post condition: la liste est triée par ordre croissant
Cas de base
1. La liste vide => l’élément n’existe pas, rien faire
2. La liste n’est pas vide et l’élément e est égale à celui de la première
cellule (e = tete^.val) => l’élément existe en entête,=>suppression
entête
3. La liste n’est pas vide et l’élément e est inférieur à celui de la première
cellule (e < tete^.val) => l’élément n’existe pas, rien faire
Processus recursif
La liste n’est pas vide et l’élément e est supérieur à celui de la première cellule
(e > tete^.val) => suppression récursive dans le reste de la liste .

Alg Avancée
44
1. Supprimer l’élément 5 de la séquence (5 = 5)=> suppression en

entête
2. Supprimer l’élément 3 de la séquence (3< 5) => l’élément
n’existe pas donc rien faire
3. Supprimer l’élément 24 de la séquence (24 > 5) => suppression
récursive du reste de la liste de tête tête^.suiv
Tête suiv
 5  10  24  45 /
 Tête^.suiv 89

(1iere proposition)
Supprimer-triée-Rec : Elément  Liste Liste
Procédure supprimer-triée-Rec (E: élément; var tete :Liste)
Var p : position
Si (tete < > nil)
Alors Si (e = tete^.val )
alors //supprision en entête
Ptete
tete  tete ^.suiv
liberer(P)
P  nil
Alors // suppression récursive de Edu reste de la liste
supprimer-triée-Rec (E, tete^.suiv )
FinSi
FinSi
FinSi
Alg AvancéeFin
45
(2ième proposition)
Supprimer-triée-Rec : Elément  Liste Liste
Procédure supprimer-triée-Rec (E: élément; var tete :Liste)
Var p : position
Si (tete < > nil)
Alors Si (e = tete^.val )
alors //supprision en entête
Supprimer-tete(tete)

Alors // suppression récursive de Edu reste de la liste
supprimer-triée-Rec (E, tete^.suiv )
FinSi
FinSi
FinSi
Alg AvancéeFin H. Jamoussi Elkamel , FSM 91
Variantes de représentation des listes

chaînées

Alg Avancée
46
Variantes de représentation des listes chaînées
On enrichit la représentation de la liste chaînée pour simplifier/faciliter

l’écriture d’un algorithme, parfois de manière temporaire :
o Pointeurs de queue
o Elément fictif placé en tête
o Listes circulaires
o Listes doublement chaînées

Alg Avancée
Liste avec pointeur en queue

Alg Avancée
47
Listes avec pointeur de queue
Tête
 A  B  C  D /
queue 
• Simplifie les ajouts en queue

• Utile pour la création par recopie d’une séquence
• Cas particuliers à traiter
o Suppression en queue nécessite la mise à jour de la queue
o Ajout dans une liste vide nécessite l’initialisation de la queue
(différent de l’insertion en tête)

Alg Avancée

Tête
 A  B  C  D /
queue 
• Cellule = Enregistrement
val: Elément
Suiv : ^Cellule
Fin
• Position = ^Cellule
• Liste = Enregistrement
Tête : Position
Queue : Position
Fin
Alg Avancée
48
Procedure Créer-Liste (var L: Fonction estvide (L:Liste) : booleen

Liste)
Début Début
L.têtenil Retourner(L.tête=nil)
L.queuenil Fin
Fin
Fonction premier (L:Liste) : Fonction dernier(L: Liste): position

Position Début
Début Retourner (L.queue)
Retourner(L.tête) Fin
Fin

Alg Avancée

• Ajout Procrdure insérer(e: Elément; p: Position; var L: Liste)
Var q: position
• Recherche de la position Début
d’insertion Allouer(q)
– Dépend de la stratégie q^.vale
d’insertion Si (EstVide(L))
• Allocation de l’espace mémoire alors // liste vide, modifier la tete et la queue
pour nouveau nœud (q^.suiv)nil
L.queue q
• Chaînage des nœuds L.tête q
• Exemple après une position p sinon
si (p=nil)
alors // liste n’est pas vide et insertion en tête
q^.suivpremier(L) // q^.suivL.tete
A  B  L.tête q
sinon
3 2 q^suivp^.suiv
p^suivq
p 1 X 
si (p=L.queue)
alors // insertion en queue
L.queueq
q Finsi
Finsi
Finsi
Fin
Alg Avancée
49
• Suppression Procrdure supprimer(p: Position; var L: Liste)
• Recherche de l’élément à Var q: position
supprimer Début
• Changement du Chaînage si (p= nil ) // suppression en tête
• Exemple après une alors
position p qtete
• Précondition : la liste n’est L.tête tête^.suiv
pas vide
Sinon // suppression milieu ou à la fin
2 qp^.suiv
p^.suivq^.suiv
A  B 
Finsi
p 3 Si (q=L.queue) // l’élément à supprimer est le dernier élément
X  alors L.queuep
1 Finsi
q Libérer(q)
Fin
Alg Avancée
Elément fictif placé en tête

Alg Avancée
50
Elément fictif placé en tête
Tête
  B  C  D /
Premier élément
de la liste
• On a toujours une liste non vide
• On accède à la liste par l’élément fictif, la tête n’est jamais modifiée
• Permet d’unifier les opérations de modification de la liste
o Ajout en tête = ajout après l’élément fictif
o Suppression en tête = suppression de l’élément après l’élément fictif
• L’introduction d’un élément fictif peut être provisoire, pour les

besoins d’un algorithme particulier
• Pas utile si l’on ne fait que des ajouts/suppressions en tête

Alg Avancée
Liste circulaire

Alg Avancée
51
Liste circulaire
Premier élément
de la liste
Tête
 A  B  C  D 
• Le dernier élément pointe sur le premier

• Utilisée pour des besoins d’application ( e.g. token ring)
• On peut avoir une liste vide
• Parfois on a un pointeur de queue plutôt que d’avoir un pointeur de
tête
o faciliter l’insertion en queue (file d’attente)
o l’élément en tête et le suivant du dernier
• Utilisée pour des besoins d’application ( e.g. token ring)
• Boucler indéfiniment sur les éléments ( e.g. jeton )
Alg Avancée
Premier élément Liste circulaire

de la liste
Tête
 A  B  C  D 
• En ce qui concerne leur déclaration, rien ne change par rapport à ce qu’on

a vu pour les listes simplement chaînées.
Type Cellule = Enregistrement Position = ^Cellule
val: Elément Liste = ^cellule
Suiv : ^Cellule
FinCellule
Var Tete : liste
• une liste vides est un pointeur nil (tete = nil)
• Le nil n’est plus un indicateur de fin de la liste, la fin de la chaine c'est aussi
l'adresse du début contenue dans le pointeur courant.
• Dernière cellule pointée par qc est tel que (qc^.suiv = tete)
Alg Avancée
52
Liste circulaire
Premier élément
de la liste
Tête
 A  B  C  D 
• Les changements affectent l’implémentation des opérations

d’initialisation, d’insertion et de suppression.

Alg Avancée
Liste circulaire avec élément fictif

Premier élément
de la liste
Tête
  B  C  D 
• Le dernier élément de la liste pointe sur l’élément fictif

• Liste circulaire jamais vide
• On accède à la liste par l’élément fictif, la tête n’est jamais modifiée
• L’élément fictif sert à repérer la fin, on peut y placer une valeur
sentinelle

Alg Avancée
53
Listes doublement chainée

Alg Avancée
Liste doublement chaînée
• On utilise des cellules (triplets) comportant 2 pointeurs :

• Cellule = enregistrement
val : Element
pred: ^Cellule
suiv : ^Cellule
finCellule
position= ^Cellule
• L’opération précédent est moins coûteuse
• Un peu gourmande en espace mémoire
• On peut bien entendu :
o Introduire un élément fictif
o Gérer des listes circulaires doublement chaînées

Alg Avancée
54
• Dans la représentation classique, le parcours des listes est orienté

dans un seul sens : du premier élément vers le dernier.
• Mais de nombreuses applications nécessitent de parcourir la liste à la
fois vers l’avant et vers l’arrière, et dans ce cas on peut faciliter le
traitement en rajoutant des pointeurs arrière ou chaînage arrière. On
obtient une liste doublement chaînée.
• La cellule d'une liste doublement chaînée possède un pointeur sur
l'élément qui le précède et un pointeur sur l'élément qui le suit:
On utilise des cellules (triplets) comportant 2 pointeurs

Alg Avancée
Tête  queue
 
/ A   B   C  D /
• On utilise des cellules (triplets) comportant 2 pointeurs :

Cellule = enregistrement position= ^Cellule
val : Element Liste = enregistrement
pred: ^Cellule tete: position
suiv : ^Cellule queue: position
FinCellule finListe
• La liste est identifiée par deux pointeurs
• On peut bien entendu : (tete , queue) pour pouvoir la parcourir
o Introduire un élément fictif dans le deux sens
o Gérer des listes circulaires doublement chaînées
Alg Avancée
55
Listes doublement chainée
Procedure Créer-Liste (var L: Fonction estvide (L:Liste) : booleen

Liste)
Début Début
L.têtenil Retourner(L.tête=nil)
L.queuenil Fin
Fin
Fonction premier (L:Liste) : Fonction dernier(L: Liste): position

Position Début
Début Retourner (L.queue)
Retourner(L.tête) Fin
Fin

Alg Avancée

pred  L.queue
• Post condition: la liste ne pas vide et l’élément est en tête de la liste
L.Tête
 
/ A   B   C  D /
5 3
4
1 2
 / E 
p pred val suiv
2 Initialiser les champs val et pred p^.val← E
p^.pred ← nil
3 Chainer la cellule à la liste p^.suiv←L.tete
4 Si la liste est vide changer la queue sinon changer le prédécesseur de la tête
Si (L.queue = nil ) alors L.queue ←p sinon L.tete^.pred ← p
5 Changer la tête L.tete ← p
56
• Post condition: la liste n’est pas vide et l’élément est en tête de la liste
 L.queue
L.Tête pred
 
/ A   B   C  D /
5 Procedure inserer-tete (var L: Liste; E: élément)
3
4
var p: position
1 2 Début
 / E  allouer(p)
p pred val suiv p^.val← E
p^.pred ← nil
p^.suiv←L.tete
Si (L.queue = nil ) // liste inialement vide
alors L.queue ←p
sinon L.tete^.pred ← p
FinSi
L.tete ←p
H. Jamoussi Elkamel , FSM
Alg Avancée 113
Fin

Problème Inserer-après : Permet d’insérer un élément E dans
une liste après une position q

• Insère un élément E après la position q dans la liste.

• q est la position de la dernière cellule : insertion en queue
• q est une position entre deux cellules : insertion au milieu

Alg Avancée
57
ajout au milieu après une position q
Prés condition : la liste n’est pas vide
 L.queue
L.Tête suiv pred
 
/ A   B   C  D /
5 6
4 3
q 
  E2 
p 1 pred val suiv
2 Initialiser les champs val p^.val← E
3 Chainer la cellule à la liste p^.suiv←q^.suiv
4 p^.pred ← q
5 Détourner le chaînage q^.suiv←p
6 p^.suiv^.pred ← p
Alg Avancée
ajout en queue
L.queue
L.Tête suiv 
 A   B 
/  C / 6
5
4
q 
 E2 / 3
p 1 pred val suiv
2 Initialiser les champs val p^.val← E
3 Initialiser pred de p à nil p^.suiv←nil // p^.suiv←q^.suiv
4 Chainer la cellule à la liste p^.pred ← q
5 q^.suiv← p
6 Changer la queue de la liste L.queue← p
Alg Avancée
58
 L.queue
L.Tête suiv pred
 / A 
Le cas où q pointe sur la  B   C   D /
dernière cellule de la liste 5 6
4 3
entre dans le cas général q 
sauf l’étape 6 qui change  E2 
Procedure
p 1 pred val suiv
inserer-apres (var L: Liste; q: position E: élément)
var p: position
Début
allouer(p)
p^.val← E
p^.suiv←q^.suiv
p^.pred ← q
q^.suiv←p
si (q= dernier(L) alors L.queue ← p
sinon p^.suiv^.pred ← p
FinSi 117
Fin
Suppression d’un élément à une position p
Problème Supprimer : Permet de supprimer l’élément de la

position p
Supprimer : Position  Liste Liste

• Supprime l’élément à la position p
la position p est une position dans la liste

• P est la position du premier élément : suppression en tête
• P est la position du dernier élément : suppression en queue
• p est une position entre deux cellules : suppression au milieu

Alg Avancée
59
P= premier(L) // p=L.tete
// p^.pred = nil
2
pred  L.queue
L.Tête
 
/ A 
3
 B   C  D /
1
p 
1 Si la liste contient un seul élément
alors changer la queue sinon Changer pred du suivant de la tête (c-à-d de p )
si premier(L) = dernier(L) // si (p^.suiv = nil )
alors L.queue←nil // alors L.queue ← p^.pred
Sinon L. tete^.suiv^.pred← nil // sinon p^.suiv^.pred← p^.pred
2 Changer la tête L.tete ← L.tete^.suiv
3 Détruire la cellule libérer(p)

Alg Avancée

3
pred  L.queue
L.Tête
 
/ A 
4
 B   C  D /
2
1 Procedure supprimer-tete (var L : Liste)
 var p: position
Début
p p ← L.tete
Le cas: la liste si premier(L) = dernier(L) // liste avec une seule cellule
contient un seul alors L.queue←nil
élément entre dans Sinon L.tete^.suiv^.pred← nil
le cas général: après Finsi
la suppression la
L.tete ← L.tete^.suiv
liste dévient vide.
liberer(p)
p← nil 120
Fin
60
Suppression au milieu à une position p
P< > premier(L) // p < > L.tete // p^.pred < > nil
P< > dernier(L) // p < > L.queue // p^.suiv < > nil
2
 L.queue
L.Tête suiv pred
 
/ A   B   C  D /
4
1 3
q  p 
1 Sauvegarder l’adresse de la cellule précédente q ←p^.pred
2 Changer le chaînage q^.suiv ← p^.suiv
3 p^.suiv^.pred ← q
Alg Avancée
Suppression en queue
• P= dernier(L) //p^.suiv = nil
• Le cas où p pointe la dernière cellule entre dans le cas suppression milieu : q^.suiv
prend la valeur NIL 3 L.queue

L.Tête suiv 2
 / A   B /  C /
4
1 p 
q 
1 Sauvegarder le prédécesseur de p q ←p^.pred
2 Si la liste contient un seul élément
alors changer la tete sinon Changer le suivant de q
si premier(L) = dernier(L) // si (p^.pred = nil )
alors L.tete ←nil // alors L.tete ← p^.suiv
Sinon q^.suiv← nil // sinon q^.suiv← p^.suiv
3 Changer la queue L.queue ← q
4 Détruire la cellule H. Jamoussi Elkamel , FSM
libérer(p) 122
Alg Avancée
61
Suppression d’un élément à une position p
Procedure Supprimer (p: position; var L : Liste )
var q : position
Début
si (p^.pred= nil) alors // suppression en tête
L.tete ← p^.suiv
sinon
q ←p^.pred
q^.suiv← p^.suiv // p^.pred^.suiv ← p^.suiv
FinSi
si (p^.suiv= nil) alors // suppression en queue

L.queue ← p^.pred
sinon 2
q ←p^.pred suiv pred
p^.suiv^.pred← q  B   4C   D 
// p^. suiv^. pred ← p^.pred
FinSi 1 3
liberer(p) q p
p← nil
Fin
62

Ch4 - Les Listes

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Ch4 - Les Listes

Transféré par

Droits d'auteur :

Formats disponibles

Complexité et structures des

FSM de Monastir 2020-2021

H. Jamoussi Elkamel , FSM 3

Introduction : Notion d’une liste

• Notation : L = <e1, e2, e3,…, en>

H. Jamoussi Elkamel , FSM 5

Les opérations sur une Liste

• Les observateurs (méthodes d’accès Access Methods)

H. Jamoussi Elkamel , FSM 6

H. Jamoussi Elkamel , FSM 7

Type Abstrait des Données Liste

précédent : Liste  Position  Position

H. Jamoussi Elkamel , FSM 10

• Une structure des données est un ensemble des cellules de

Implémentation statique d’une Liste

L’implémentation statique d’une liste peut se faire à l’aide d’un

– Un tableau est un espace des cases mémoires qui sont contigües.

H. Jamoussi Elkamel , FSM 12

Implémentation dynamique d’une Liste

H. Jamoussi Elkamel , FSM 15

Liste simplement chainée

H. Jamoussi Elkamel , FSM 16

Liste simplement chainée

H. Jamoussi Elkamel , FSM 20

5416 Ben ali Mohamed 20  0416 Kilani Aya 21 

5416 Ben salah Salah 20  5416 Bhouri Emna 22 

H. Jamoussi Elkamel , FSM 21

Accès à la liste chaînée

Début et fin de la liste

Fonction estvide (tete : Liste) : booleen

H. Jamoussi Elkamel , FSM 24

Fonction premier (tete :Liste) : Position

H. Jamoussi Elkamel , FSM 25

Début et fin de la liste

H. Jamoussi Elkamel , FSM 27

Parcours d’une liste chaînée

Pour parcourir les éléments de la liste chaînée, nous avons besoin de :

H. Jamoussi Elkamel , FSM 28

Affichage des éléments d’une liste

Calcul longueur d’une liste

On commence le parcours de la liste à partir de la tête (la première

H. Jamoussi Elkamel , FSM 33

 Création d’une liste vide

Alg Avancée H. Jamoussi Elkamel , FSM

Création d’une liste vide

Procedure Créer-Liste (var tete : Liste)

H. Jamoussi Elkamel , FSM 36

Insérer-tete : Elément  Liste Liste

Ajout d’un élément en tête

1 Créer une nouvelle cellule pointé par p allouer(p)

Ajout d’un élément après une position q

Insérer-après : Elément  position  Liste Liste

Deux cas possibles :

H. Jamoussi Elkamel , FSM 40

Le fait d'insérer plutôt qu'ajouter un élément dans la liste

Trois cas sont possibles :

H. Jamoussi Elkamel , FSM 44

Insérer-kième : Elément  entier  Liste Liste

Si la liste est vide alors insertion en entête

H. Jamoussi Elkamel , FSM 45

Insérer un élément comme kième élément( 1iere proposition)

Insérer-apres(E, qpred, tete)

H. Jamoussi Elkamel , FSM 47