Cours sur les piles

Structure de pile et opérations sur les piles
Définition
Une pile est une structure de données (abstraite) qui autorise les trois opérations fondamentales suivantes :
- l'empilage d'un objet, c'est à dire son insertion dans la structure
- le dépilage du dernier objet qui a été empilé dans la structure
- le test qui détermine si la pile est vide ou non.
Commentaires
Concrètement, une pile est donc une structure de données que l’on peut comparer à une pile de cartes ou
d’assiettes.
Pour accéder à l’élément situé à la base de la pile, il faut commencer par enlever tous ceux qui sont situés au
dessus.
Cette structure est parfois qualifiée de LIFO (Last In First Out).
Exemple d’utilisation :
Stockage de l’historique des actions effectuées dans un logiciel afin de gérer une fonction d’annulation de
ces actions dans l’ordre inverse.
Implémentation en python
La première idée qui vient à l’esprit est d’utiliser une liste python (variable de type list) en guise de pile.
Notons qu’une liste python a une taille redimensionnable en fonction des besoins, ce qui convient pour
représenter une pile dont la taille maximale est a priori indéterminée.
Mais en toute rigueur une variable de type list est plus qu’une simple pile (on peut par exemple accéder
directement à n’importe quel élément d’une liste, ce qui est interdit pour une pile), et il faudrait donc inventer un
nouveau type (le type pile). C’est possible en python, car c’est un langage de programmation orienté objet (POO) :
il est possible de créer une « classe » pile qui possède les propriétés de la structure de pile.
Exemple de réalisation d’un module contenant une classe « pile »
# Définition d’une classe pile, d’attributs et de méthodes #########
class pile(object): # Déclaration de classe
"""Classe pile, structure de données que l'on peut empiler, dépiler
et à laquelle on ne peut accéder que par le sommet.
Il est interdit de modifier les attributs sommet et liste à l'extérieur de la classe"""
Les fonctions disponibles sont :
pile_vide() est_vide(p) litsommet(p) taille(p)"""
def __init__ (self,sommet,liste): # Définition de la méthode constructeur, sert à initialiser l’objet et à définir les attributs ;
self.S=sommet # self représente l’objet, S est l'attribut sommet
self.L=liste # L est l'attribut de la liste des éléments de la pile
def empile(self,v): # Définition d'une méthode qui empile la valeur v sur la pile
"""Ajoute la valeur v au sommet de la pile"""
self.L.append(v)
self.S=v
def depile(self): # Définition d'une méthode qui depile la pile et renvoie la valeur dépilée
"""Supprime le sommet de la pile p
et retourne sa valeur (pour une pile non vide)"""
if len(self.L)>0:
x=self.S # x contient l'ancien sommet à retourner en fin de procédure
self.L.pop() # On supprime l'ancien sommet
if len(self.L)>0: # On redéfinit le nouveau sommet s'il existe, sinon il vaut None
self.S=self.L[-1]
else:
self.S=None
return x # permet d'affecter l'élément dépilé dans le programme appelant
else:
print("Pile vide, rien à dépiler") # signale si la pile est vide

# Définition de fonctions (pas d’indentation) pour créer une pile vide, retourner le sommet, la taille de la pile, tester si la pile est vide #####
def pile_vide():
"""Retourne une pile vide"""
return(pile(None,[])) # permet d'affecter une pile vide dans le programme appelant
def est_vide(p):
"""Retourne True si p est vide, False sinon"""
return len(p.L)==0 # True si vide
def litsommet(p):
"""Retourne la valeur du sommet de la pile p"""
return p.S
def taille(p):
"""Retourne le nombre d’éléments de la pile p"""
return len(p.L) # permet d'affecter la taille dans le programme appelant
Utilisation du module ClassePile
On peut soit recopier le script en amont du programme que l’on veut écrire, soit importer le module
ClassePile qui aura été précompilé (fichier ClassePile.pyc) et placé dans le dossier 'D:\Travaux\TDinfo' (par
exemple).
On peut alors utiliser les opérations fondamentales sur les piles : on commence par créer une pile vide avec
la fonction pile_vide(), puis on empile des objets avec la méthode empile, on en dépile avec la méthode depile, on
teste si la pile est vide avec la fonction est_vide(p). Exemple :
## Import des modules
from ClassePile import * # Importer toutes les fonctions du module (On peut les trouver avec help(pile))
## Script principal
p=pile_vide()
p.empile(5)
p.empile('a')
print("p est-elle vide ?",est_vide(p))
On peut utiliser deux opérations (fonctions) complémentaires qui ont été définies dans ClassePile dans le but
de faciliter la conception et la lecture d’algorithmes utilisant des piles : litsommet(p) et taille(p).
En effet si la pile p n’est pas vide, on peut aisément lire l’élément du sommet de la pile : il suffit d’affecter
une variable x en utilisant la méthode depile, puis de rempiler x avec la méthode empile. Cette opération s’écrira
plus simplement avec la fonction litsommet(p).
De même on peut évaluer le nombre d’éléments dans la pile p en la dépilant dans une pile vide q tout en
incrémentant un compteur i jusqu’à ce que p soit vide, puis de dépiler q en l’empilant dans p pour restaurer p. Là
encore cette opération s’écrira beaucoup plus simplement avec la fonction taille(p). Exemple :
print("sommet de p :",litsommet(p))
print("taille de p :",taille(p))
Conclusion : En imposant l’usage d’objets de type pile plutôt que de type list on interdit au programmeur
l’utilisation des fonctionnalités des objets list non conformes à la structure de pile, ce qui limite les risques
d’erreur de programmation.
Structure de file (complément hors programme)
Une structure de données analogue à la pile est la structure de file (ou queue). On peut la comparer à une
file d’attente à l’entrée d’une salle de cinéma. On entre dans la file à sa base, on en ressort à son sommet. Il s’agit
d’une structure FIFO (First In First Out).
Exemple d’utilisation :
Gestion d’une file de tâches d’impression sur l’imprimante d’un serveur d’impression.