Les Piles

1
 Les piles
Une pile est une liste dans laquelle toutes les insertions et toutes les
suppressions se font en tête.

Utilisation :
 Par un compilateur, lors des appels de fonctions : Avant de se
brancher vers la fonction appelée, le compilateur sauvegarde l’adresse
de retour et les variables du programme appelant, afin de les restituer
au retour de la fonction. De plus, les retours se font dans le sens
inverse des appels, ce qui coïncide bien avec la structure LIFO de la
pile.
 Par un compilateur, pour l’évaluation des expressions
arithmétiques : ce dernier point est détaillé dans ce qui suit.
(a+(b-c))/d

 Parcours en profondeur des arbres

 ……
2
 Opérations sur les piles
 Empiler un élément : l’action consistant à ajouter un nouvel
élément au sommet de la pile

 Désempiler un élément : l’action consistant à retirer

l’élément se trouvant au sommet de la pile

 Consultation : consulter l’élément se trouvant au sommet de

la pile. L’état de la pile ne change pas suite à cette opération

3
 Représentation des piles en mémoire
On peut représenter ou implémenter les files en mémoire de façon :

 Contiguë
tete

50 -5 12 111

Désempiler Empiler

 Chaînée
Sommet Quatre

tete Trois

300 Deux
Quatre Trois Deux Un Un
600 500 800 nil

4
 Représentation chaînée
 Déclaration
Type Pile= enregistrement Type Pile : ^Cellule ;
info :<type_elt> ; Type Cellule : Enregistrement
svt : ^Pile ; info: <type_elt> ;
Fing ; svt : Pile ;
Var Fing ;
L : ^Pile ; Var
L : Pile ;

tete
tete 50

300 -5
50 -5 12 111 12
600 500 800 nil 111

5
 Représentation chaînée
 Tester si la pile est vide

Fonction Pile_vide(E/ tete: Pile) : booléen

Début
Si (tete = nil) alors retourne vrai ;
sinon retourne faux ;
Fsi ;
Fin ;
tete
300
50 -5 12 111

100 500 800 nil

tete
nil

6
 Représentation chaînée

 Initialiser la pile

Fonction Init_Pile( ) : Pile

Début
retourne (nil) ;
Fin ;

tete
nil

7
 Représentation chaînée
 Consulter l’élément se trouvant en tête de la Pile

Fonction sommet_pile(E/ tete : Pile) : <type_ele>

Début
Retourne (tete^.info) ;
Fin
50
tete 50
tete
-5
300
12
50 -5 12 111
111
100 500 800 nil

8
Empiler : Ajout d’un élément
Procédure Empiler(ES/ tete Pile, E/ e :<Type_elt>)
Début
nouv : pile

Allouer (nouv) ;
si (nouv ≠ nil) alors
nouv^.inf  e ;
nouv^.svt  tete ;
tete nouv ;
Fsi;
Fin ;
tete
nil
700 nouv
700

un
nil
un tete
9
Empiler : Ajout d’un élément
Procédure Empiler(ES/ tete Pile, E/ e :<Type_elt>)
nouv : pile

Allouer (nouv) ;
si (nouv ≠ nil) alors
nouv^.inf  e ;
nouv^.svt  tete ;
tete nouv ;
sinon écrire (mémoire saturée)
Fsi;
Fin
tete tete nouv tete
600 nouv 900 700
600 900
Trois tete
Deux tete
Trois Deux Un
Un tete
900 700 nil

10
Désempiler: suppression d’un élément
Procédure désempiler(ES/ tete: Pile, S/ e :<Type_elt>)
Début
p : Pile ; // le test si la pile est vide se fait dans le prog principal

e  sommet_pile(tete) ; (* e  tete^.info *)
p tete ;
tete tete^.svt ;
Libérer(p) ;
Fin

e
Trois tete p tete
700 700 300
Trois tete
Deux tete
Trois Deux Un Un
300 900 nil
Désempiler: suppression d’un élément
Procédure désempiler(ES/ tete: Pile, S/ e :<Type_elt>)
Début
p : File ; // le test si la file est vide se fait dans le prog principal

e  sommet_pile(tete) ; (* e  tete^.info *)
p tete ;
tete tete^.svt ;
Libérer(p) ;
Fin

tete p tete
e
300 300 900
Deux

Deux Un Deux tete

900 nil Un tete
12
Désempiler: suppression d’un élément
Procédure désempiler(ES/ tete: Pile, S/ e :<Type_elt>)
Début
p : File ; // le test si la file est vide se fait dans le prog principal

e  sommet_pile(tete) ; (* e  tete^.info *)
p tete ;
tete tete^.svt ;
Libérer(p) ;
Fin

e tete p tete

900 900 nil

Un

Un

nil Un tete
13
 Représentation contigüe
 Déclaration
On peut représenter une pile par un tableau alloué d’une manière statique. On
peut choisir le couple suivant : (T, Tete) pour manipuler cette pile.

Constante max _tab 100 ;

Type Pile = Enregistrement
T : tableau [max_tab] <Type_Elt> ;
Tete : entier ;
Fing ;
p : Pile ;

max_tab
tete
10
4

50 -5 12 111

14
 Représentation contigüe
 Initialisation

Fonction InitPile ( ) : Pile

Début
p : Pile ;

p.Tete 0;
Retourner (p);
Fin
p.Tete max_tab
0 10

15
 Représentation contigüe
 Tester si la pile est vide

Fonction PileVide (E/ p : Pile) : booléen

Debut
Si (p.Tete=0) alors retourner (vrai) ;
sinon retourner (faux) ;
fsi ;
Fin

p.Tete max_tab
4 10

50 -5 12 111

16
 Représentation contigüe
 Tester si la pile est pleine

Fonction PilePleine (E/ p : Pile) : booléen

Début
si (p.Tete = max_tab) alors retourner (vrai) ;
sinon retourner (faux) ;
fsi ;
Fin
Max_tab
p.Tete elt
10
10

50 -5 12 111 5 88 -12 77 100 90

17
 Représentation contigüe
 Consulter l’élément se trouvant en tête de pile

Fonction sommet_pile (E/ p: Pile) : <TypeElt>

Début
retourner (p.T[p.Tete]) ;
Fin

p.Tete max_tab 111

4 10

50 -5 12 111

18
 Empiler : Ajout d’un élément
Procédure Empiler (ES/ p: Pile, E/ e : <TypeElt>)
Début
p.tete  p.tete + 1; (* le test si la pile est pleine se fait dans le PP *)
p.T[p.tete]  e;
Fin

e max_tab
25 10
p.Tete
87

50 -5 12 111 0 56 -40 25

19
 Désempiler : suppression d’un élément
Procédure Désempiler(ES/ p: Pile, S/ e :<Type_elt>)
Début
e  p.T[p.tete] ; (* le test si la pile est vide se fait dans le PP *)
p.Tete  p.Tete - 1;
Fin

e max_tab
- 40 10
p.Tete
76

50 -5 12 111 0 56 -40

20
 Utilisation des piles :évaluation des expressions
arithmétiques
Problème:
A= 5+(5*2/5)–3 = 4
A = (5 + 5) * 2 / 5 – 3 = 1

L’évaluation des expressions n’est pas directe puisque dès la rencontre d’un opérateur
on ne sait pas quelle opération doit-on évaluer d’abord. Ceci dépend :

• Priorités des opérateurs dans le cas d’une expression non parenthésée

• Position des parenthèses dans le cas d’une expression parenthésée.

Une utilisation courante des piles est l’élaboration par le compilateur d’une forme
intermédiaire de l’expression à évaluer (exemple : A+B). Après l’analyse lexicale et
syntaxique, l’expression est traduite en une forme intermédiaire plus facilement
évaluable (exemple : AB+).
La notation < Opérande> < Opérateur> < Opérande> est dite INFIXE.
A + B
La notation < Opérande Gauche > < Opérande Droit > < Opérateur> est dite POSTFIXE
A B +

21
 Evaluation des expressions arithmétiques
Deux algorithme à utiliser pour évaluer une expression arithmétique:

 Algorithme 1 : transformation d’une forme infixée en une forme postfixée

A= 8 + ( 5 * 2 / 5 ) – 3 8 5 2 * 5 / + 3 -

 Algorithme 2 : évaluation d’une forme postfixée

8 5 2 * 5 / + 3 - A= 7

Algo 1
Algo 2
transformation d’une
forme infixée en une évaluation
A= 8 + ( 5 * 2 / 5 ) – 3 forme postfixée : d’une forme
8 5 2 * 5 / + 3 - postfixée

A= 7
22
Algo 1 : transformation d’une forme infixée en
une forme postfixée
L’algorithme utilise deux piles P et R. Il reçoit comme donnée l’expression
arithmétique, rangée dans un vecteur T de taille : Taille_Expression. Il utilise les
fonctions suivantes supposées définies.

 Operateur(x)
détermine si x est un opérateur : + (addition), - (soustraction), *(multiplication), /
(division) et % (reste de la division entière)

 Operande(x)
détermine si x est un opérande. Un opérande peut être une suite de symboles
représentant un entier ou un réel

 Priorite(x)
retourne la priorité de l’opérateur x
Priorité(+) = Priorité(-) < Priorité(*) = Priorité(/) = Priorité(%)

 Opération (x1, x2, operateur)

effectue l’opération (x1 operateur x2) et retourne le résultat
23
Début
P<- Init_pile (); R<- Init_pile ();
Pour i <- 1 à Taille_Expression
Faire
Si (Operande (T[i]) alors Empiler (R, T[i]) ; fsi ;
Si (T[i]= ‘(‘ ) alors Empiler (P, T[i]) ; fsi ;
Si (Operateur ( T[i] ) alors
Tant que (non PileVide(P) et Operateur (SommetPile(P)) et (Priorité (T[i]) ≤ Priorité (SommetPile(P)))
Faire
Désempiler (P, x) ; Empiler (R, x) ;
Fait
Empiler (P, T[i]);
Fsi ;
Si (T[i] = ‘)‘ ) alors
Tant que (non PileVide(P) et (SommetPile (P) ≠ ‘(’ )
Faire
Désempiler (P, x) ;
Empiler (R, x) ;
Fait
Désempiler (P, x) ;
Fsi
Fait
Tant que (non PileVide(R))
Faire Désempiler (R, x) ; Empiler (P, x) ; Fait 24
Fin
Début
P<- Init_pile (); R<- Init_pile (); 8 + ( 5 * 2 / 5 ) - 3
Pour i <- 1 à Taille_Expression
Faire
Si (Operande (T[i]) alors Empiler (R, T[i]) ; Fsi ;
Si (T[i]= ‘(‘ ) alors Empiler (P, T[i]) ; Fsi ;
Si (Operateur ( T[i] ) alors
TQ (non PileVide(P) et Operateur (SommetPile(P)) et (Priorité (T[i]) ≤ Priorité (SommetPile(P)))
Faire
Désempiler (P, x) ; Empiler (R, x) ;
Fait; 8
Empiler (P, T[i]); 5 3
Fsi ; 2 +
Si (T[i] = ‘)‘ ) alors
* /
Tant que (non PileVide(P) et (SommetPile (P) ≠ ‘(’ )
Faire 5 5
Désempiler (P, x) ; / *
Empiler (R, x) ;
+*/ 2
Fait
Désempiler (P, x) ; 3( 5
Fsi +- 8
Fait ;
Tant que (non PileVide(R)) P R
8 5 2 * 5 / + 3 -
Faire Désempiler (R, x) ; Empiler (P, x) ; Fait; 25
Fin
 Algo 2 : Algorithme d’évaluation d’une forme
postfixée
L’algorithme utilise deux piles P et R. La pile P contient la forme postfixée de l’expression et la
pile R étant initialement vide. Le résultat final se trouvera dans la pile R et la pile P devient vide.

Début
R <- Init_pile ();
Tant que (non PileVide(P))
Faire
Désempiler (P, x) ;
Si (Operande (x)) alors Empiler (R, x) ;
Sinon /* c’est un opérateur */
Désempiler (R, x1) ;
Désempiler (R, x2) ;
Res = Opération (x2, x1, x) ;
Empiler (R, Res) ;
Fsi ;
Fait ;
Fin
26
 Algo 2 : Algorithme d’évaluation d’une forme
postfixée
Début
R <- Init_pile ();
Tant que (non PileVide(P))
Faire
Désempiler (P, x) ;
Si (Operande (x)) alors Empiler (R, x) ;
8
Sinon /* c’est un opérateur */
Désempiler (R, x1) ; 5
Désempiler (R, x2) ; 2
Res = Opération (x2, x1, x) ;
*
Empiler (R, Res) ;
Fsi ; 5
Fait ; /
Fin + 2
5
Res 3
x 10
5
3
2
10
5810
*/+25-23=10
===210
7 -
52
8
5
+*/3- 10
7
8
P R
x1 23
5
2 x2 10
5
8
27
 Exemple d’application
Une image en informatique peut être représentée par une matrice de points
ayant N lignes et M colonnes. Un élément Image[x, y] de la matrice représente la
couleur du point de coordonnées (x, y). En utilisant la pile comme structure de
donnée, on propose d’écrire un programme qui, à partir d’un point p donné, étale
une couleur c autour de ce point. Pour effectuer le remplissage, on doit aller dans
toutes les directions à partir d’un point de départ p. La progression de la couleur
étalée s’arrête quand elle rencontre une couleur autre que celle du point p.

28
T: Tab[8][8] : couleur; 1 2 3 4 5 6 7 8

c1 , c : couleur; // c : la nouvelle couleur grise 1

cz , z : cordo ; // z : point de départ z=(4,4) 2

p : pile ; 4

c1  T [4][4] ; //récupérer la couleur de la case z=(x, y): rouge 5

p  initpile ( ) ; 6
Empiler (p, (4,4)) ; z
7
TQ (non pilevide(p)) (4,5)
(4,6)
(5,3)
(5,5)
(6,4)
(4,3)
(6,3)
(5,2)
(5,4)
(4,4)
(3,5)
(2,4)
(3,4)
(3,3)
(4,4) c1 8
Faire
Désempiler (p, z) ;
si (T[z.x][z.y] = c1) // c1=rouge
Alors
T[z.x][z.y]  c ; // c= marron
si (z.x >1) alors cz  z ; cz.x  cz.x-1 ; empiler (p, cz) ; fsi ; // haut (5,4)
(4,6)
si (z.x < 8) alors cz  z ; cz.x  cz.x+1 ; empiler (p, cz) ; fsi ; // bas
si (z.y >1) alors cz  z ; cz.y  cz.y-1 ; empiler (p, cz) ; fsi ; // gauche (5,2)
(4,4)
si (z.y < 8) alors cz  z ; cz.y  cz.y+1 ; empiler (p, cz) ; fsi ; // droite (6,3)
(5,5)
Fsi ; (5,3)
(4,3)
(3,5)
(4,5)
Fait
(6,4)
(3,3)
(4,3)
Fin ;
(5,4)
(4,4)
(2,4)
(4,4)
(3,4)
29
P
T: Tab[8][8] : couleur; 1 2 3 4 5 6 7 8

c1 ; c : couleur; // c : la nouvelle couleur grise 1

cz , z : cordo ; // z : point de départ z=(4,4) 2

p : pile ; 4

// récupérer la couleur de la case z=(x, y) couleur rouge 5

c1  T [4][4] ; 6
p  initpile ( ) ; z
7
Empiler (p, (4,4)) ; (2,4) c1 8
TQ (non pilevide(p))
Faire
Désempiler (p, z) ;
si (T[z.x][z.y] = c1) // c1=rouge
Alors
T[z.x][z.y]  c ; // c= marron
si (z.x >1) alors cz  z ; cz.x  cz.x-1 ; empiler (p, cz) ; fsi ; // haut
si (z.x < 8) alors cz  z ; cz.x  cz.x+1 ; empiler (p, cz) ; fsi ; // bas
si (z.y >1) alors cz  z ; cz.y  cz.y-1 ; empiler (p, cz) ; fsi ; // gauche
si (z.y < 8) alors cz  z ; cz.y  cz.y+1 ; empiler (p, cz) ; fsi ; // droite
Fsi ;
Fait
Fin ;
(2,4)
30
P
FIN

31