Vous êtes sur la page 1sur 41

Hind ELOUEDI

1
Plan
 Introduction
 Notion de pointeur
 Les listes chaînées
 Les piles
 Les files
 Conclusion

2
Introduction

 Exemples introductifs
 Exemple 1 : Insertion dans un tableau
 On dispose d’un tableau T d’entiers déjà rempli de n entiers et de taille
maximale MAX.
 On veut insérer un élément e saisi après un entier donné a, si ce dernier
existe dans le tableau, à défaut l’entier e sera mis à la fin du tableau.
 Le tableau T a une taille maximale, à un certain moment on peut arriver
à saturation et on ne peut plus insérer : problème des déclarations
statiques (fixes).

3
Introduction (2)
 Exemples introductifs (2)
 Exemple 2 : Transfert de données d’un fichier à un tableau
 On dispose d’un fichier de structure étudiant contenant le numéro
d’inscription, le nom et la moyenne de l’étudiant.
 On veut transférer l’ensemble des moyennes >=10 dans un tableau TM de
réels afin d’élaborer des statistiques.
 On se confronte à un problème : On ne connait pas à l’avance le nombre
d’étudiants ayant une moyenne >=10 et par conséquent on ne pourra
pas définir la taille de notre tableau à l’avance !

4
Introduction (3)

 Exemples introductifs (3)


 Comment remédier à ces problèmes ?
 Dans les deux exemples précédents, la structure de données Tableau ne
résout pas le problème, et on aura toujours du gaspillage d’espace ou
une saturation.
 On doit alors penser à une structure de données qui donne exactement
l’espace nécessaire : Cette structure de données va être variable selon
le besoin de l’exécution courante : On parle alors de structures de
données dynamiques.

5
Notion de pointeur
 Idée
 Jusque-là, et pour représenter les données, nous avons utilisé des
variables de types simples (entier, réel, caractère,…) ou composés
(tableau ou enregistrement) d’une manière statique, c’est-à-dire
l’espace mémoire est réservé au préalable même s’il n’est pas utilisé
en totalité (tel est le cas d’un tableau).
 Chaque variable déclarée est reconnue à travers son identificateur
(nom) et aussi son adresse en mémoire.
 L’accès à une variable pourrait alors se faire à travers son adresse.
 Le contenu d’une variable peut aussi être une adresse, et dans ce cas
cette variable est appelée pointeur.

6
Notion de pointeur (2)
 Définition: Un pointeur est une variable spéciale pouvant contenir
l’adresse d’une autre variable.

Objet pointé
Pointeur p
A0F12345
Zone Mémoire

.
.
.

 Remarques
 Le rôle d'un pointeur est de permettre l'accès à une structure qui serait créée avant
ou lors de l'exécution.
 La déclaration doit spécifier le type de base de l'objet qui pourra être accessible à
l'aide du pointeur. 7
Notion de pointeur (3)
 Représentation
 Il ne s’agit pas de représenter seulement P en tant que variable mais également le
lien existant entre P et l’autre variable.
 Si P est un pointeur qui contient l’adresse d’une variable dont le contenu est la
valeur a, on peut alors représenter ce fait par le schéma suivant :


P@

P contient l’adresse de la variable contenant la valeur a, cette zone


est notée: P@ (la zone pointée ou adressée par le pointeur P.
8
Notion de pointeur (4)
 Déclaration
 On représentera alors algorithmiquement de la façon suivante:

Type
Type_Pointeur = @Objet
Variable
P : Type_Pointeur -- ou directement P: @Objet

 Exemples:
Type
Etudiant = Enregistrement
Num : Entier
Nomp : Chaîne[30]
Adr : Chaîne[50]
FinEnregistrement
Variable
Pe: @Etudiant -- Pe: désigne la variable qui contient l’adresse et Pe@: désigne l’objet pointé par Pe
P: @Entier -- P: désigne la variable qui contient l’adresse et P@ : désigne l’objet pointé par P
9
Notion de pointeur (5)
 Exercice
 On considère deux variables P1 et P2 de type pointeur permettant d’accéder respectivement aux
valeurs a et b. Que donnera l’exécution de l’action P1P2 ?
 Situation initiale:
P1 P2

 
P2@
P1@

a b

 L’exécution de l’action P1  P2 donnera le schéma suivant : P1  P2 implique que dans P1 on va


placer l’adresse de P2, donc P1 va pointer sur l’adresse contenant l’information b, on aura alors :
P1 P2

 
P2@, P1@

a b
10
Notion de pointeur (6)
 Remarques
 L’instruction P1@  P2@: signifie que la variable adressée par P1 contiendra la
valeur contenue dans la variable adressée par P2. Donc la variable adressée par P1
contiendra la valeur b (selon l’exercice précédent).
 L’instruction P  Nil, initialise un pointeur à une adresse nulle ce qui signifie qu’il
ne pointe aucun objet.
 Primitives de manipulation
 Pour une variable statique la réservation de la zone mémoire se fait au moment de
la compilation et restera disponible tout au long de l’exécution du programme.
 Pour les variables de type pointeur, qui ont l’aspect d’être dynamique, la réservation
de l’espace mémoire se fait au cours de l’exécution du programme à l’aide de la
primitive Allouer: Allouer (P) (P est un pointeur).
 Au cours de cette même exécution, si on juge ne plus avoir besoin de cette variable,
on peut s’en passer (la libérer), on utilise alors la primitive Libérer: Libérer (P).
 Si P est un pointeur, Allouer (P) signifie qu’on va trouver un emplacement mémoire
libre suffisant pour contenir un objet pointé par P. 11
Les listes chaînées
 Introduction
 En utilisant les pointeurs, on va implémenter des structures afin de représenter
listes chaînées (qui sont linéaires).
 Ces listes peuvent être simplement chaînées, ou doublement chaînées ou circulaires.

 Listes simplement chaînées (LSC)


 Définition:
 Une liste est une structure particulièrement souple : elle peut grandir ou rétrécir à volonté, et ses
éléments, peuvent être insérés ou supprimés à n’importe quel endroit.
 Une liste chaînée est une structure de données semblable à un tableau sauf que l'accès à un élément ne
se fait pas par index mais à l'aide d'un pointeur.
 L'allocation de la mémoire est faite au moment de l'exécution. Dans une liste les éléments sont
contigus en ce qui concerne l'enchaînement (mais pas nécessairement en espace mémoire).
 Une liste chaînée est manipuler à partir d’un certain nombre d’opérations élémentaires qu’on appelle
primitives.
 D’un point de vue mathématique, une liste est une suite, vide ou non, d’éléments d’un type donné
(soit TypeElem). Il est habituel de représenter une telle suite par : (a1, a2, …, an) où n est positif ou nul,
et où chaque ai est de type TypeElem.
12
Les listes chaînées (2)
 Listes simplement chaînées (2)
 Déclaration:
 Pour définir une cellule (un élément) de la liste, on
utilisera le type enregistrement.
 L'élément de la liste contiendra un champ Info et un
pointeur suivant (Suiv).
 Le pointeur suivant doit être du même type que
l'élément, sinon il ne pourra pas pointer vers l'élément Représentation d’une cellule
suivant. Le pointeur « Suiv" permettra l'accès vers le
prochain élément.

Type
TypeElem = … -- TypeElem est un type simple, ou composé,…
Cellule = Enregistrement
Info : TypeElem -- Information utile
Suiv : @Cellule -- Pointeur sur l’élément du suivant
FinEnregistrement
Liste = @Cellule
Variable
L : Liste --  L : @Cellule : une variable d’accès à la liste
-- On a deux champs: L@.Info et L@.Suiv
13
Les listes chaînées (3)
 Listes simplement chaînées (3)
 Représentation:
 Si la liste est composée de la suite (a1, a2, a3,…, an), la cellule contenant ai pointe sur celle contenant ai+1,
pour i = 1, 2, 3, …, n-1. La dernière cellule contenant an n’a pas de successeur et son pointeur aura la
valeur « Nil ».
 La connaissance de la première adresse de la chaîne est suffisante pour traiter celle-ci en sa totalité.
Cette adresse doit se trouver dans une variable que nous appellerons très souvent « L ».
 Dans le cas d'une liste vide, « L » pointe sur « Nil », et la structure ne contient pas d’autres cellules.

Représentation d’une liste simplement chaînée

14
Les listes chaînées (4)
 Listes simplement chaînées (4)
 Exemples de déclaration:

Type
Etudiant = Enregistrement
NCE: Entier -- Numéro de la carte d’étudiant
Nomp: Chaine[30] -- Nom et prénom de l’étudiant
Moy: Réel -- Moyenne générale de l’étudiant
CelluleEt = Enregistrement
Info : Etudiant -- Information relative à un étudiant
Suiv : @CelluleEt -- Pointeur sur l’élément du suivant
FinEnregistrement
ListeEt = @CelluleEt -- Un type liste représentant des étudiants
CelluleNbr = Enregistrement
Nbr: Entier
Suiv: @CelluleNbr
FinEnregistrement
ListeNbr = @CelluleNbr -- Un type liste représentant des entiers
Variable
LE: ListeEt --  L : @CelluleEt : une variable d’accès à la liste
LN: ListeNbr -- --  L : @CelluleNbr : une variable d’accès à la liste
15
Les listes chaînées (5)
 Listes simplement chaînées (5)
 Primitives sur les listes simplement chaînées: Opérations de base.
1. Initialisation d’une liste: Cette opération doit se faire 3. Taille d’une liste: Permet de déterminer le nombre
avant toute autre opération sur la liste. d’éléments d’une liste (version récursive).
Procédure Init_Liste (Var L : Liste) Fonction Taille (Don L : Liste) : Entier
-- Précondition: - -- Précondition: -
-- Postcondition: transforme la liste L en liste vide -- Postcondition: Taille(L)=Nombre d’éléments de la liste L
Début Début
L  Nil Si Vide (L)
Fin Alors Taille  0
Sinon
2. Test de liste vide: Permet de tester si une liste est vide ou Taille  1 + Taille (L@.Suiv)
pas. FinSi
Fonction Vide (Don L : Liste) : Booléen Fin
-- Précondition: -
-- Postcondition : Vérifie si la liste L est vide 4. Premier élément d’une liste:
Début Fonction Premier (Don L : Liste) : TypeElem
Si (L = Nil) Alors Vide  Vrai -- Précondition: Non Vide (L)
Sinon Vide  Faux -- Postcondition : retourne le premier élément de L
FinSi Début
Fin Premier  L@.Info
Fin 16
Les listes chaînées (6)
 Listes simplement chaînées (6)
 Primitives sur les listes simplement chaînées: Opérations de base.
5. Dernier élément d’une liste: 7. Insertion au ébut d’une liste:
Fonction Dernier (Don L : Liste) : TypeElem Procédure InsérerDébut (Var L : Liste, Don E : TypeElem)
-- Précondition: Non Vide (L) -- Précondition: -
-- Postcondition: retourne le dernier élément de la liste L -- Postcondition: L' ayant tous les éléments de la liste L
Début -- et en tête un élément contenant E
Si (Taille (L) = 1) -- ou L@.Suiv = Nil -- Si L contient (a1, a2, … an), elle devient (E, a1, a2, … an)
Alors Dernier  L@.Info -- Premier (L’) =E, Reste (L’)=L et Taille (L’) =Taille (L) + 1
Sinon Dernier  Dernier (L@.Suiv) Variable
FinSi c : @Cellule -- ou c : Liste
Fin Début
Allouer (c)
6. Reste d’une liste: c@.Info  E
Fonction Reste (Don L : Liste) : Liste c@.Suiv  L
-- Précondition: Non Vide (L) Lc
-- Postcondition: renvoie L sans le premier élément Fin
-- Si L contient (a1, a2, … an), Reste(L) = (a2, a3,… an)
Début
Reste  L@.Suiv
Fin
17
Les listes chaînées (7)
 Listes simplement chaînées (7)
 Primitives sur les listes simplement chaînées: Opérations de base.

8. Insertion à la fin d’une liste: version récursive 9. Suppression en tête de liste:


Procédure InsérerFin (Var L : Liste ; Don E : TypeElem) Procédure SupprimerTete (Var L : Liste)
-- Précondition: - -- Précondition: Non Vide (L)
-- Postcondition: L' ayant tous les éléments de la liste L -- Postcondition: L' ayant tous les éléments de la liste L
-- et en queue un élément contenant E -- sans le premier élément
-- Si L contient (a1, a2, … an), elle devient (a1, a2, … an, E) -- Si L contient (a1, a2, … an), elle devient (a2, … an)
-- Dernier (L’)=E, Reste (L’)=L et Taille (L’) = Taille (L) + 1 -- L' = Reste (L) et Taille (L’) = Taille (L) - 1
Début Variable
Si Vide (L) p : Liste
Alors InsérerDébut (L, E) Début
Sinon InsérerFin (Reste (L), E) p L
FinSi L  Reste (L)
Fin Libérer (p)
Fin

18
Les listes chaînées (8)
 Listes simplement chaînées (8)
 Primitives sur les listes simplement chaînées: Opérations de base.

9. Face d’une liste: version récursive 10. Parcours d’une liste: pour affichage ou traitement de
Fonction Face (Don L : Liste) : Liste données.
-- Précondition: Non Vide (L) Procédure ParcoursListe (Don L : Liste)
-- Postcondition: renvoie la liste L sans le dernier élément -- Précondition: Non Vide (L)
-- Si L contient (a1, a2, … an), Face (L) = (a1, a2,…an-1) -- Postcondition: Affiche ou traite les différents
Variable -- éléments de la liste donnée en paramètre
L1 : Liste Variable
Début c : Liste
Si (Taille (L) = 1) -- ou L@.Suiv = Nil Début
Alors Face  Nil cL
Sinon L1  Face (Reste (L)) Tant Que (c  Nil) Faire
InsérerDébut (L1, Premier (L)) Ecrire (c@.Info) -- ou faire un traitement
Face  L1 c  c@.Suiv
FinSi FinTantQue
Fin Fin

19
Les listes chaînées (9)
 Listes doublement chaînées (LDC)
 Définition:
 Dans une liste doublement chaînée ou bidirectionnelle, il suffit de connaître l’adresse du premier
élément pour pouvoir accéder à tous les autres (comme dans une liste simplement chaînée).
 En plus du pointeur qui donne l’adresse de la cellule ou de l’élément suivant, chaque élément est doté
d’un autre pointeur qui indique l’adresse du précédent. Ceci permet à partir de n’importe quel point
de la liste de connaître les éléments qui se trouvent de part et d’autre.
 Représentation:

Représentation d’une liste doublement chaînée: (a1, a2, a3, a4)

20
Les listes chaînées (10)
 Listes doublement chaînées (2)
 Déclaration:

Type
TypeElem = … -- TypeElem est un type simple, ou composé,…
Cellule = Enregistrement
Prec: @Cellule -- Pointeur sur l’élément précedent
Info : TypeElem -- Information utile
Suiv : @Cellule -- Pointeur sur l’élément du suivant
FinEnregistrement
ListeD = Enregistrement
Debut: @Cellule -- Pointeur sur le premier élément
Fin: @Cellule -- Pointeur sur le dernier élément
FinEnregistrement
Variable
LD: ListeD -- Cette liste a pour champs: LD.Debut, LD.Fin
-- A son tour, LD.Debut a les champs: LD.Debut@Prec, LD.Debut@.Info et LD.Debut@.Suiv
-- LD.Fin a les champs: LD.Fin@.Prec, LD.Fin@.Info et LD.Fin@.Suiv

 Pour accéder à un élément la liste peut être parcourue dans les deux sens :
 en commençant avec la tête, le pointeur Suiv permettant le déplacement vers le prochain élément.
 en commençant avec la queue, le pointeur Prec permettant le déplacement vers l'élément précédent.
21
Les listes chaînées (11)
 Listes doublement chaînées (3)
 Primitives sur les listes doublement chaînées: Opérations de base.
1. Initialisation d’une liste: Cette opération doit se faire avant 3. Taille d’une liste: Permet de déterminer le nombre
toute autre opération sur la liste. d’éléments d’une liste (version récursive).
Procédure Init_Liste (Var LD : ListeD) Fonction Taille (Don LD : ListeD) : Entier
-- Précondition: - -- Précondition: -
-- Postcondition: transforme la liste LD en liste vide -- Postcondition: Taille (LD)=Nbre d’éléments de la liste LD
Début Début
LD.Debut  Nil Si Vide (LD)
LD.Fin  Nil Alors Taille  0
Fin Sinon
Taille  1 + Taille (LD.Debut@.Suiv)
2. Test de liste vide: Permet de tester si une liste est vide ou FinSi
pas. Fin
Fonction Vide (Don LD : ListeD) : Booléen
-- Précondition: - 4. Premier élément d’une liste:
-- Postcondition : Vérifie si la liste LD est vide Fonction Premier (Don LD : ListeD) : TypeElem
Début -- Précondition: Non Vide (LD)
Si (LD.Debut = Nil) Alors Vide  Vrai -- ou LD.Fin=Nil -- Postcondition : retourne le premier élément de LD
Sinon Vide  Faux Début
FinSi Premier  LD.Debut@.Info
Fin Fin
22
Les listes chaînées (12)
 Listes doublement chaînées (4)
 Primitives sur les listes doublement chaînées: Opérations de base.
5. Dernier élément d’une liste: C’est plus simple à retrouver 7. Face d’une liste: C’est plus simple à retrouver qu’avec une
qu’avec une liste simplement chaînée. liste simplement chaînée.
Fonction Dernier (Don LD : Liste) : TypeElem Fonction Face (Don LD : ListeD) : ListeD
-- Précondition: Non Vide (LD) -- Précondition: Non Vide (L)
-- Postcondition: retourne le dernier élément de la liste LD -- Postcondition: renvoie la liste L sans le dernier élément
Début -- Si LD contient (a1, a2, … an), Face (LD) = (a1, a2,…an-1)
Premier  LD.Fin@.Info Variable
FinSi LF: ListeD
Fin Début
LF.Debut  LD.Debut
6. Reste d’une liste: LF.Fin  LD.Fin@.Prec
Fonction Reste (Don LD : ListeD) : ListeD Face  LF
-- Précondition: Non Vide (LD) Fin
-- Postcondition: renvoie LD sans le premier élément
-- Si LD contient (a1, a2, … an), Reste (LD) = (a2, a3,… an)
Début
Reste  LD.Debut@.Suiv
Fin
23
Les listes chaînées (13)
 Listes doublement chaînées (5)
 Primitives sur les listes doublement chaînées: Opérations de base.

8. Insertion dans une liste vide: la seule situation où 9. Insertion au début:


LD.Debut et LD.Fin sont mis à jour. Procédure InsérerDebut (Var LD : Liste, Don E: TypeElem)
Procédure InsérerVide (Var LD : Liste, Don E: TypeElem) -- Précondition: Non Vide (LD)
-- Précondition: Vide (LD) -- Postcondition: L’élément E est ajouté au début de LD
-- Postcondition: La liste LD contiendra un seul élément Variable
Variable NouvE: @Cellule
NouvE: @Cellule Début
Début Allouer (NouvE)
Allouer (NouvE) NouvE@.Info  E
NouvE@.Info  E NouvE@.Prec  Nil
NouvE@.Prec  Nil NouvE@.Suiv  LD.Debut
NouvE@.Suiv  Nil LD.Debut@.Prec  NouvE
LD.Debut  NouvE LD.Debut  NouvE
LD.Fin  NouvE Fin
Fin

24
Les listes chaînées (14)
 Listes doublement chaînées (6)
 Primitives sur les listes doublement chaînées: Opérations de base.

10. Insertion à la fin: 11. Suppression en tête


Procédure InsérerFin (Var LD : Liste, Don E: TypeElem) Procédure SupprimerTete (Var TD: ListeD)
-- Précondition: Non Vide (LD) -- Précondition: -
-- Postcondition: L’élément E est ajouté à la fin de LD -- Postcondition: L’élément en tête est supprimé
Variable -- Si la liste contient un seul élément il faut mettre à jour
NouvE: @Cellule -- le pointeur de fin LD.Fin et la liste devient vide
Début Variable
Allouer (NouvE) s: @Cellule
NouvE@.elem  E Début
NouvE@.suiv  Nil s  LD.Debut
NouvE@.Prec  LD.Fin LD.Debut  LD.Debut@Suiv
LD.Fin@.Suiv  NouvE Si (LD.Debut = Nil)
LD.Fin  NouvE Alors LD.Fin  Nil
Fin FinSi
Libérer (s)
Fin

25
Les listes chaînées (15)
 Listes doublement chaînées (7)
 Primitives sur les listes doublement chaînées: Opérations de base.

12. Suppression en fin de liste 13. Parcours inverse: parcourir la liste à partir de la fin
Procédure SupprimerFin (Var LD: ListeD) Procédure ParcoursInv (Don LD : ListeD)
-- Précondition: - -- Précondition: Non Vide (LD)
-- Postcondition: L’élément à la fin est supprimé -- Postcondition: Affiche ou traite les différents
-- Si la liste contient un seul élément il faut mettre à jour -- éléments de la liste donnée en paramètre en faisant
-- le pointeur de début LD.Debut et la liste devient vide -- le parcours à partir de la fin
Variable Variable
s: @Cellule c : Liste
Début Début
s  LD.Fin c  LD.Fin
LD.Fin  LD.Fin@Prec Tant Que (c  Nil) Faire
Si (LD.Fin = Nil) Ecrire (c@.Info) -- ou faire un traitement
Alors LD.Debut  Nil c  c@.Prec
FinSi FinTantQue
Libérer (s) Fin
Fin

26
Les listes chaînées (16)
 Listes circulaires
 Définition:
 La liste circulaire est une sorte de liste simplement ou doublement chaînée, qui comporte une
caractéristique supplémentaire, "elle n'a pas de fin".
 Pour rendre la liste sans fin, le pointeur suivant du dernier élément pointera sur le premier élément
de la liste au lieu de la valeur Nil, que nous avons vu dans le cas des listes simplement et doublement
chaînées.
 Dans les listes circulaires, nous n'arriverons jamais à une position depuis laquelle nous ne pourrons
plus nous déplacer. En arrivant au dernier élément, le déplacement recommencera au premier
élément. En bref, il s'agit d'une rotation.
 Représentation:

Représentation d’une liste circulaire: (a1, a2, a3, a4)


27
Les listes chaînées (17)
 Listes circulaires (2)
 Déclaration:
 La déclaration d’une liste circulaire simplement chaînée est similaire à la déclaration d’une liste
simplement chaînée. La différence se trouve au moment d’effectuer les traitements

Type
TypeElem = … -- TypeElem est un type simple, ou composé,…
Cellule = Enregistrement
Info : TypeElem -- Information utile
Suiv : @Cellule -- Pointeur sur l’élément du suivant
FinEnregistrement
Liste = @Cellule
Variable
L : Liste --  L : @Cellule : une variable d’accès à la liste
-- On a deux champs: L@.Info et L@.Suiv

28
Les listes chaînées (18)
 Listes circulaires (3)
 Quelques traitements

1. Parcours d’une liste circulaire 2. Insertion dans une liste vide:


Procédure Parcours (Var L: Liste) Procédure InsérerVide (Var L : Liste, Don E: TypeElem)
-- Précondition: Non Vide (L) -- Précondition: Vide (L)
-- Postcondition: Parcourir tous les éléments -- Postcondition: La liste contiendra un seul élément
Variable Variable
p: Liste NouvE : Liste
Stop: Booléen Début
Début Allouer (NouvE)
pL NouvE@.Info  E
Stop  Faux NouvE@.Suiv  NouvE
Tant Que (Non Stop) Faire L  NouvE
Ecrire (p@.Info) -- ou traiter p@.Info Fin
p  p@.Suiv -- p  Reste (p)
Stop  (p = L)
FinTantQue
Fin

29
Les piles
 Définition
 La structure de pile est une structure de liste particulière permettant d’exprimer le
comportement d’une pile d’assiettes: on peut ajouter et enlever des assiettes au
sommet de la pile; toute insertion ou retrait d’une assiette en milieu de pile est une
opération qui comporte de risque (la pile s’écroule).
 La stratégie de gestion d’une pile est dernier arrivé, premier servi. En anglais on
dira « Last In First Out », plus connu sous le nom de « LIFO ». Le dernier élément
d’une pile est appelé Base de la pile; le premier élément est appelé Sommet de la
pile. Les opérations de mise à jour (insertion et suppression), d'après la définition,
se font à partir du sommet.
 Exemple d’utilisation des piles: Les algorithmes à essais successifs reposent
fréquemment sur la récursivité et ont besoin de sauvegarder la situation avant un
essai pour pouvoir y revenir si cet essai est terminé. Cette sauvegarde s'effectue
dans une pile puisque tout retour en arrière doit ramener à la situation la plus
récente.
30
Les piles (2)
 Représentation
P

a4 Sommet de la pile
a3
a2
a1 Nil Base de la pile

Représentation de la pile P (a1, a2, a3, a4)

31
Les piles (3)
 Déclaration

Type
TypeElem = … -- TypeElem est un type simple, ou composé,…
Cellule = Enregistrement
Info : TypeElem -- Information utile
Suiv : @Cellule -- Pointeur sur l’élément du suivant
FinEnregistrement
Pile = @Cellule
Variable
P : Pile --  P : @Cellule : une variable d’accès à la pile
-- On a deux champs: P@.Info et P@.Suiv

32
Les piles (4)
 Primitives sur les piles: Opérations de base
1. Initialisation d’une pile:
Procédure InitPile (Var P: Pile)
-- Précondition: - 3. Sommet d’une pile:
-- Postcondition: transforme la pile P en pile vide Fonction Sommet (Don P: Pile) : TypeElem
Début -- Précondition: Non PileVide (P)
P  Nil -- Postcondition: retourne l’élément au sommet de P
Fin Début
Sommet  P@.Info
2. Test de pile vide: Fin
Fonction PileVide (Don P: Pile) : Booléen
-- Précondition: -
-- Postcondition: retourne vrai si P est vide et faux sinon
Début
PileVide  (P = Nil)
Fin

33
Les piles (5)
 Primitives sur les piles (2): Opérations de base

4. Ajout d’un élément: Empiler un élément (au sommet) 5. Suppression d’un élément: Dépiler un élément (le
Procédure Empiler (Var P : Pile ; Don E : TypeElem) sommet)
-- Précondition: - Procédure Depiler (Var P : Pile ; Var E : TypeElem)
-- Postcondition: P' ayant tous les éléments de la pile P -- Précondition: Non PileVide (P)
-- et en tête un élément contenant E. -- Postcondition: P' ayant tous les éléments de la pile P
-- Si P contient (a1, a2, … an), elle devient (E, a1, a2, … an) -- sans le sommet
Variable -- Si P contient (a1, a2, … an), elle devient (a2, … an) et E=a1
c : Pile Variable
Début c : Pile
Allouer (c) Début
c@.Info  E cP
c@.Suiv  P E  P@.Info
Pc P  P@.Suiv
Fin Libérer (c)
Fin

34
Les files
 Définition
 Une file est un type particulier de liste, où les éléments sont insérés en queue et
supprimés en tête.
 Le nom vient des files d’attente à un guichet, où le premier arrivé est le premier
servi, ce qui justifie le terme anglo-saxon de « FIFO » (First In First Out).
 Les files sont d’un usage très répandu dans la programmation système.
 Les opérations sur une file sont analogues à celles définies sur les piles, la principale
différence provenant du fait que les insertions se font en fin de liste plutôt qu’en
début.

35
Les files (2)
 Représentation
 Étant donné que l’insertion se fait toujours en dernière position, il est commode,
afin d’accélérer l’algorithme, de disposer du pointeur sur la dernière cellule de la
file d’attente.
 On peut définir une file comme la donnée de deux pointeurs : un premier sur la tête
de file et un second sur la queue. On représente donc une file d’attente par:

Représentation de la file F (a1, a2, a3, a4)

36
Les files (3)
 Déclaration

Type
TypeElem = … -- TypeElem est un type simple, ou composé,…
Cellule = Enregistrement
Info : TypeElem -- Information utile
Suiv : @Cellule -- Pointeur sur l’élément du suivant
FinEnregistrement
File = Enregistrement
tête : @Cellule -- tête pointe sur l’élément de début
queue : @Cellule -- queue pointe sur l’élément de fin
FinEnregistrement
Variable
F : File -- une variable d’accès à la file
-- on F.tête et F.queue de type pointeur sur cellule

37
Les files (4)
 Primitives sur les files: Opérations de base
1. Initialisation d’une file: 3. Tête d’une file:
Procédure InitFile (Var F: File) Fonction Tête (Don F: File) : TypeElem
-- Précondition: - -- Précondition: Non FileVide (F)
-- Postcondition: transforme la file F en file vide -- Postcondition: retourne l’élément à la tête de F
Début Début
F.tête  Nil Tête  F.tête@.Info
F.queue  F.tête Fin
Fin
4. Queue d’une file:
2. Test de file vide: Fonction Queue (Don F: Pile) : TypeElem
Fonction FileVide (Don F: File) : Booléen -- Précondition: Non FileVide (F)
-- Précondition: - -- Postcondition: retourne l’élément à la fin de F
-- Postcondition: retourne vrai si F est vide et faux sinon Début
Début Queue  F.queue@.Info
FileVide  (F.tête = F.queue Et F.Tête = Nil) Fin
Fin

38
Les files (5)
 Primitives sur les files (2): Opérations de base
5. Ajout d’un élément dans une file: L’ajout se fait à la fin, il 6. Suppression d’un élément d’une file: Elle se fait toujours
s’git d’enfiler un élément. en tête, il s’agit de défiler un élément de la file.
Procédure Enfiler (Var F : File, Don E : TypeElem) Procédure Défiler (Var F : File, Var E : TypeElem)
-- Précondition: - -- Précondition: Non Vide (F)
-- Postcondition: F' ayant tous les éléments de la file F -- Postcondition: F' ayant tous les élts de F sans le 1er élt
-- et en queue un élément contenant E -- Si F contient (a1, a2, … an), elle devient (a2, … an) et E=a1
-- Si F contient (a1, a2, … an), elle devient (a1, a2, … an, E) Variable
Variable c : @Cellule
c : @Cellule Début
Début c  F.tête
Allouer (c) E  F.tête@.Info
c@.Info  E F.tête  F.tête@.Suiv
c@.Suiv  Nil Si (F.tête = Nil)
Si (FileVide (F)) Alors F.queue  Nil
Alors F.tête  c FinSi
Sinon F.queue@.Suiv  c Libérer (c)
FinSi Fin
F.queue  c
Fin
39
Conclusion

 Les structures dynamiques utilisent les pointeurs dans leurs implémentations.


 Les différentes primitives décrites pour les listes serviront pour écrire des
algorithmes plus élaborés.
 Les piles et les files représentent des cas particuliers de listes, c’est pour cela qu’elles
ont un nombre limité de primitives définies relativement à leurs modes de
fonctionnement. Toute autre manipulation de ces structures doit se servir de ces
primitives et respecter le mode de fonctionnement de ces structures.

40
A Suivre…

41