Les piles et les files

Les piles
 Définition et exemple
 Une pile est une liste ordonnée d’éléments dans laquelle on ne peut
introduire ou enlever un élément qu'à une extrémité appelée tête de
pile ou sommet de pile.
 Exemple
 une pile de livres
 une pile d’assiettes,

 Dans une pile, le dernier élément inséré sera le premier à

être supprimé : on parle de liste LIFO (Last In First Out).
Les piles
 Opérations sur les piles
 Les opérations de base sur les piles sont :
 InitialiserPile(p) : vide la pile p
 PileVide(p) : retourne Vrai si la pile est vide sinon Faux.
 Empiler (p,e) (push) : empile l’élément e dans la pile p
 Dépiler (p) (pop): dépile un élément de la pile et retourne la valeur
de cet élément (e ← Depiler (p))
 SommetDePile(p) : retourne le sommet de pile sans le supprimer
(e ← SommetDePile(p))
Les piles
 Implémentation d’une pile par tableau : Pile statique
 Une pile statique est un TAD représenté par un enregistrement
contenant :
 un tableau à hauteur maximale prévisible
 un indice entier qui pointe la dernière valeur ajoutée à la pile (sommet).

 Modélisation : Pile d’entier

constante
N = …. /* taille du tableau*/
type
Tab = Tableau [1..N] d’entier
Pile =Enregistrement
sommet : entier
T : Tab
Fin Pile
Les piles
 Les opérations sur une pile statique

PROCEDURE InitialiserPile(var p : Pile)

Debut
p.sommet← 0
Fin
*********************************************************************************************************************************

FONCTION PileVide(p : Pile) : booléen

Debut
si ( p.sommet =0) alors
Retourner vrai
Sinon
Retourner faux
fin si
Fin
Les piles
 Les opérations sur une pile

PROCEDURE Empiler (var p : Pile, e : entier)

Debut
Si p.sommet =N Alors
Ecrire("Impossible la pile est pleine")
Sinon
p.sommet ← p. sommet + 1
p.T [p. sommet] ← e
FinSi
Fin
Les piles
 Les opérations sur une pile
FONCTION Dépiler (var p : Pile) : entier
Var
X : entier
Debut
Si PileVide (p) Alors
Ecrire("Impossible la pile est vide")
sortir
Sinon
X ← p.T [p. sommet]
p. sommet ← p. sommet – 1
Retourner (X)
FinSi
Fin
Les piles
 Les opérations sur une pile

FONCTION SommetDePile (p : Pile) : entier

Debut
Si (PileVide(p)) alors
Ecrire ("la pile est vide")
sortir
Sinon
Retourner p.T[p.sommet]
Finsi
Fin
Les piles
 Implémentation d’une pile par liste chaînée : Pile
dynamique
 L’implémentation d’une pile par une liste (simplement) chaînée est
une version simplifiée de celle d’une liste par liste chaînée:
type
maillon = Enregistrement
valeur : entier
suivant : ^maillon
Fin maillon
liste : maillon
Pile =Enregistrement
sommet : ^liste
Fin Pile
Les piles
 Les opérations sur une pile

PROCEDURE InitialiserPile(var p : Pile)

Debut
p.sommet← Nil
Fin

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

FONCTION PileVide(p : Pile) : booléen

Debut
si ( p.sommet =Nil) alors
Retourner vrai
Sinon
Retourner faux
fin si
Fin
Les piles
 Les opérations sur une pile

PROCEDURE Empiler (var p : Pile, e : entier)

Debut
InsertTete(p.sommet,e)
Fin

nouvElt ← nouveau(^liste)
nouvElt ^.valeur ← e
nouvElt ^.suivant ← p.sommet
p.sommet ← nouvElt
Les piles
 Les opérations sur une pile

FONCTION Dépiler (var p : Pile) : entier

var
e : entier
Debut
si (PileVide(p)) alors
Ecrire ("la pile est vide")
sortir
sinon
e ← p.sommet^.valeur
SuppTete(p)
aux ← p.sommet
retourner e p.sommet← p.sommet^.suivant
finsi liberer(aux)
Fin
Les piles
 Les opérations sur une pile

FONCTION SommetDePile (p : Pile) : entier

Debut
si (PileVide(p)) alors
Ecrire ("la pile est vide")
sortir
sinon
Retourner p.sommet^.valeur
finsi
Fin
Les piles
 Exercice 1 : Entiers Pairs
1. Ecrire une fonction qui prend en entrée une pile
d’entier et qui modifie la pile en supprimant les entiers
pairs et fournit en sortie la liste des entiers pairs
supprimés.
 Exemple:
 la pile [1,4,5,2,3,6,8[ (où 1 est le fond de pile) est transformée
 en la pile [1,5,3[ où (1 est le fond de pile)
 et la liste fournie est (4,2,6,8),
 les entiers sont dans l’ordre de leur entrée dans la pile.

2. Donnez la complexité de votre fonction.

Les piles
 Exercice 2 : Utilisation d'une pile, pour le calcul des
expressions écrites en « postfixé »
L'expression dite "infixée" (4+5)*6 s'écrit en "postfixé 4 5 + 6*
On utilise alors une pile pour pouvoir effectuer les calculs.
Les règles d'utilisation sont alors les suivantes:
Si on rencontre
- un nombre : on l'empile
- une opération : on dépile le sommet et le sous sommet
on effectue le calcul sous-sommet "opération" sommet
on empile le résultat

Pour simplifier, on supposera que les opérandes numériques sont donnés sur un seul
chiffre de 0 à 9.
Les piles
 Exercice 2 : Utilisation d'une pile, pour le calcul des
expressions écrites en « postfixé »
Pour ce faire :
– créer une fonction qui teste si un caractère c donné en paramètre est
une opération arithmétique('+','-','*','/').
– créer une fonction qui calcule le résultat de l'opération a op b
(avec op = '+','-','*' ou '/'), les deux opérandes et l’opération sont donnés
en paramètre.
– créer une fonction qui évalue une expression en postfixé donnée en
paramètre sous forme de chaîne caractère.
– Utiliser la fonction d’évaluation dans un algorithme principal.
Les piles
 Exercice 3 :Test du bon « Parenthésage »
Un problème fréquent d’un compilateur et des traitements de
textes est de déterminer si les parenthèses d’une chaîne de
caractères sont balancées et proprement incluses l’une dans l’autre.
 Par exemple
 la chaîne ((( ) ) ( ) )( ) est bien balancée,
 les chaînes )( ) ou ( ) ) ne le sont pas.

Ecrire une fonction qui retourne vrai si une chaîne de caractères est
proprement écrite et bien balancée, et faux sinon.
Les files
 Définition
 Une file est une structure de données dans laquelle on insère de
nouveaux éléments à la fin (queue) et on enlève des éléments au
début (tête de file).

 Exemple
 Clients devant un guichet,
 Les travaux en attente d’exécution dans un système de traitement
par lots
Les files
 Dans une file, le premier élément inséré est aussi le premier
retiré.
 On parle de mode d’accès FIFO (Fisrt In Fist Out).
 Contrairement à la pile, la file est modifiée à ses deux extrémités.

 Les opérations sur une file

 Initialiser une file vide
 Tester si une file est vide
 Calculer la taille d’une file
 Défiler pour le retrait d’un élément
 Enfiler pour l’ajout d’un élément.
 L’opération Enfiler (f, e) ajoute l’élément e à la fin de la file f.
Les files
 Ajouter un élément : Enfiler
 La suite des opérations Enfiler (f, A), Enfiler (f, B) et Enfiler (f,
C) donnent la file suivante :
Les files
 Supprimer un élément : Défiler
 L’opération e ← Defiler (f), supprime le premier élément en
tête de file et renvoie sa valeur dans e.

e ←A

 L'opération Defiler ne peut s’effectuer sur une file vide.

 Il faudra donc utiliser une opération FileVide qui permet de tester si
une file est vide ou pas.
Les files
 Implantation d’une file par tableau : File statique
 Une file statique est un TAD modélisé par un enregistrement à 3 cases :
 un tableau à hauteur maximale prévisible,
 un indice entier qui pointe le premier élément inséré dans la file (sommet)
 un deuxième indice entier qui pointe la dernière valeur ajoutée (queue).

 Modélisation : File d’entier

constante
N = …. /* taille du tableau*/
type
Tab = Tableau [1..N] d’entier
File =Enregistrement
sommet ,queue: entier
T : Tab
Fin File
Les files
 Les opérations sur une file
PROCEDURE InitialiserFile(var f : File)
Debut
f.sommet← 0
f.queue← 0
Fin
*********************************************************************************************************************************

FONCTION FileVide(f : File) : booléen

Debut
si ( f.queue =0) alors
Retourner vrai
Sinon
Retourner faux
fin si
Fin
Les files
 Les opérations sur une file

FONCTION Taille (f : File,) : entier

Debut
si FileVide(f ) alors
retourner 0
sinon
si (f.sommet<=f.queue) alors
retourner f.queue – f.sommet+1
sinon
retourner f.queue +N- f.sommet+1
fin si
fin si
Fin
Les files
 Les opérations sur une file
PROCEDURE Enfiler (var f : File, e : entier)
Debut
Si (Taille(f)=N) Alors
Ecrire("Impossible la file est pleine")
Sinon
Si FileVide(f) alors
f.sommet ← 1
Fin si
Si (f.queue=N) alors
f.queue ← 1
sinon
f. queue ← f. queue + 1
fin si
f.T [f.queue] ← e
Fin si
Fin
Les files
 Les opérations sur une file
FONCTION Defiler (var f : File) : entier
Var
e : entier
Debut
Si FileVide(f) Alors
Ecrire("Impossible la File est vide")
Sortir
Sinon
e ← f.T [f. sommet]
si (f.sommet=f.queue) alors
f.sommet ← 0
f.queue ← 0
sinon
si (f.sommet=N) alors
f.sommet ← 1
sinon
f. sommet← f. sommet+ 1
fin si
fin si
Retourner(e)
Fin si
Fin
Les files
 Implantation d’une file par liste chaînée : File
dynamique
 L’implantation d’une file par une liste (simplement) chaînée est
une version simplifiée de celle d’une liste par liste chaînée.
 Il n’y a aucune limite aux nombres d’éléments que l’on peut ajouter dans
une file.
type
maillon = Enregistrement
valeur : entier
suivant : ^maillon
Fin maillon
liste : maillon
File =Enregistrement
sommet,queue : ^liste
Fin File
Les files
 Les opérations sur une file
PROCEDURE InitialiserFile(var f : File)
Debut
f.sommet← Nil
f.queue← Nil
Fin
*********************************************************************************************************************************

FONCTION FileVide(f : File) : booléen

Debut
si ( f.queue =Nil) alors
Retourner vrai
Sinon
Retourner faux
fin si
Fin
Les files
 Les opérations sur une file
PROCEDURE Enfiler (var f : File, e : entier)
Var
nouvElt : ^liste
Debut
nouvElt ← nouveau(^liste)
nouvElt ^.valeur ← e
nouvElt ^.suivant ← Nil
si (FileVide(f)) alors
f.sommet ← nouvElt
sinon
f.queue^.suivant ← nouvElt
Fin si
f.queue ← nouvElt
Fin
Les files
 Les opérations sur une file
FONCTION Defiler (var f : File) : entier
var
e : entier
p : ^liste
Debut
si (FileVide(f)) alors
Ecrire ("la file est vide")
sortir
sinon
e ← f.sommet^.valeur
p ← f.sommet
f.sommet ← f.sommet^.suivant
si (f.sommet=Nil) alors
f.queue ← Nil si sommet devient Nil
finsi cela veut dire que la file
libérer(p) a été vidée et
retourner(e)
queue doit devenir Nil
finsi
Fin
Les files
 Exercice 1 : file d’attente au cinéma
Considérons une file d’attente devant un cinéma. La file initialement
vide se remplit au fur et à mesure que les individus arrivent avec une
gestion particulière liée au fait que si un nouvel individu aperçoit
dans la file un ami, alors il se joint à lui pour attendre. Pour
manipuler cette liste d’attente, vous considérerez que les individus
sont représentés par des entiers. Deux amis seront alors deux
entiers identiques. La structure de données utilisée pour
représenter la liste devra donc intégrer non seulement l’individu,
mais aussi le nombre d’occurrences associé
1. Proposez une structure de données permettant de gérer une telle file,
2. Ecrire la fonction permettant d’ajouter un nouvel individu dans une
telle file,
3. Ecrire la fonction permettant de retirer le premier individu d’une telle
file.
Les files

 Exercice 2 : Réussite d’horloge