Le document présente les piles comme des structures de données de type LIFO, permettant d'ajouter (push) et de retirer (pop) des éléments uniquement depuis le sommet. Il explique les opérations sur les piles, leur implémentation en langage de programmation, et fournit des exemples d'algorithmes utilisant des piles pour résoudre des problèmes variés. Des exercices pratiques sont également proposés pour manipuler les piles et simuler la récursivité.

1. 1
Chapitre 3: Les Piles
Année Universitaire 2023/2024
Niveau : 1
Semestre II
sana.refai@gmail.com

2. Introduction ( ½)
Une pile est une liste chaînée d'informations dans
laquelle :
 Un élément ne peut être ajouté qu'au sommet de la
pile,
 Un élément ne peut être retiré que du sommet de la
pile.
Il s'agit donc d'une structure de type LIFO (Last In First
Out). On ne travaille que sur le sommet de la pile. Les
piles sont comparables à des piles d'assiettes.
2

3. Introduction ( 2/2)
.
On associe à une pile les termes de :
 PUSH pour empiler c'est-à-dire ajouter un élément,
 POP pour dépiler c'est-à-dire supprimer un élément
Les piles servent à revenir à l'état précédent et sont utilisées
pour :
 implanter les appels de procédures (pour revenir à l'état
d'avant l'appel),
 annuler une commande,
 évaluer des expressions arithmétiques,
 etc.
3

4. Les opérations sur les piles
Les opérations autorisées avec une pile sont :
 empiler, toujours au sommet, et jusqu’à la limite de la
mémoire,
 dépiler, toujours au sommet, si la pile n’est pas vide,
 vérifier si la pile est vide ou non.
4

5. Implémentation
On peut implémenter une pile dans un tableau (pile
statique) ou dans une liste chaînée (pile dynamique). C'est
l'implémentation en liste chaînée qui est présentée ici.
Le sommet de la pile est le premier élément et le pointeur
de tête pointe sur ce sommet. Il faut commencer par définir
un type de variable pour chaque élément de la pile.
La déclaration est identique à celle d'une liste chaînée, par
exemple pour une pile de chaînes de caractères :
5
Type Pile = ^Element
Type Element = Structure
Info : chaîne de caractères
Suivant : Pile
Fin Structure

6. Empiler(1/3)
Empiler un élément revient à faire une insertion en tête dans
la liste chaînée.
6
/* Ajout d'un élément dans une pile passée en paramètre */
Procedure Empiler (Entrée/Sortie Tête : Pile, Entrée Valeur : chaîne de
caractères)
Variable
P : Pile /* pointeur auxiliaire */
DEBUT
Allouer(P) /* Réserve un espace mémoire pour le nouvel élément */
P^.Info  Valeur /* stocke dans l'Info de l'élément pointé par P la valeur passée en
paramètre * /
P^.Suivant Tête /*stocke dans l'adresse du Suivant l'adresse de Tête */
Tête P /* Tête pointe maintenant sur le nouvel élément */
FIN

7. Empiler(2/3)
7

8. Empiler (3/3)
En faisant référence à la procédure InsereEnTete dans le
chapitre des listes chaînées simples, nous pouvons écrire
empiler un élément revient à faire une insertion en tête dans
la liste chaînée.
Puisqu’il s’agit d’une gestion dynamique de la mémoire, il
n’est pas nécessaire de vérifier si la pile est pleine.
8
/* Ajout de l'élément au sommet de la pile P passée en paramètre */
Procedure Empiler (Entrée/Sortie Tête : Pile; Entrée Element : variant)
DEBUT
InsererEnTete(Tête, Element)
FIN

9. Dépiler(1/3)
Dépiler revient à faire une suppression en tête.
9
/* Suppression de l'élément au sommet de la pile passée en paramètre */
Procedure Dépiler (Entrée/Sortie Tête : Pile)
Variable locale
P : Pile /* Pointeur nécessaire pour libérer la place occupée par l'élément dépilé */
DEBUT
/* Vérifier si la pile est vide */
SI Tête <> NIL ALORS
/* la pile n'est pas vide donc on peut dépiler */
P Tête /* on garde l'adresse du sommet pour désallouer */
Tête Tête^.Suivant /* P va pointer sur le 2ème élément de la pile qui devient le
sommet */
Désallouer(P)
FINSI
FIN

10. Exercice (1/2)
6
Ecrire les Procédures et fonctions de base pour les
piles:
Procedure InitPile (Sortie Tête : Pile)
Fonction PileVide (Tête : Pile) : booléen
Fonction SommetPile (Tête : Pile) : variant
5 minutes 10

11. Exercice (2/2)
6
11
/* Initialise la création d’une pile */
Procedure InitPile (Sortie Tête : Pile)
DEBUT
Tête  Nil
FIN
/* indique si la pile est vide ou non*/
Fonction PileVide (Tête : Pile) : booléen
DEBUT
Retourner (Tête = Nil)
FIN
/* renvoie la valeur du sommet si la pile n'est pas vide */
Fonction SommetPile (Tête : Pile) : variant
DEBUT
SommetPile Tête^.Info
FIN

12. Exercice
6
On se donne une pile P1 contenant des entiers
positifs. Ecrire un algorithme pour déplacer les
entiers de P1 dans une pile P2 de façon à avoir
dans P2 tous les nombres pairs en dessus des
nombres impairs en gardant l’ordre
d’apparition des nombre pairs et en inversant
l’ordre d’apparition des nombres impairs. Au
retour à l’algorithme appelant on doit
retrouver P1 initiale.
12

13. Exercice
6
Soit L une liste dont les cellules contiennent soit :
Une parenthèse ouvrante «(»
Une parenthèse fermante «)»
Un autre caractère
Ecrire une fonction qui reçoit la liste L et retourne vrai
si les parenthèses sont bien imbriquées et faux sinon.
Il est vivement conseillé d’utiliser une Pile.
Exemple
*La liste (ab(c)) est bien formée
*La liste (abc)) n’est pas bien formée
13

14. Exercice
6
Simuler la récursivité à l’aide d’une pile
Écrire un algorithme pour calculer la somme de 1 à n
∈ n ∈ N∗ en simulant la récursivité à l’aide d’une pile.
14
int triangularSum(unsigned n)
{ if (n == 0)
return 0;
pile p = initPile();
int val = n; int res = 0;
do
empiler(val, &p);
while (--val > 0);
do {
depiler(&val, &p);
res += val; }
while (! estPileVide(p));
return res; }

15. Exercice
6
Utiliser une pile pour Evaluer une expression
arithmétique postfixée codée sur un tableau de
caractères, en supposant pour simplifier que
– tous les opérateurs sont binaires et limités `a +, −, ∗
et /,
– on utilise uniquement des nombres sur un
caractère
Exemple:
((a * b) + ((a+b)* c)) a b * a b + c * +
15

16. 16
https://www.irif.fr/~hf//verif/ens/IF2/coursIF2
/C11.htm
https://www.emse.fr/~lalevee/ismin/program
mation_2/TP6/ExpressionArithmetiquePostfixe
e.pdf