Les piles

Les piles
23 novembre 2014
1 Introduction
Il existe de nombreux algorithmes dans lesquels on veut manipuler des ensembles
d’objets.
Un exemple est celui de votre navigateur web, qui stocke les adresses des dernières
pages visitées pour vous proposer la fonction «retour arrière».
Dans ce cas particulier, on a besoin de stocker cette liste d’adresses de façon à
pouvoir :
1. Ajouter une nouvelle adresse (lorsque vous passez sur une nouvelle page) ;
2. Récupérer la dernière adresse mise ;
3. Enlever la dernière adresse mise (l’avant-dernière devient alors la dernière, etc.).
Il y a différentes façons de stocker cette liste mais dans tous les cas, on a besoin de
les organiser, de façon à ce qu’elles offrent à peu près les mêmes opérations qu’une pile
d’assiettes (ou de livres).
On dit que l’algorithme a besoin d’une structure de pile.
En anglais : stack, ou structure LIFO (Last In First Out).
La structure de données «pile» se retrouve à de nombreux endroits en informatique :
1

— dans le fonctionnement interne d’un ordinateur, pour gérer les appels de fonctions,
on garde une pile des variables locales et des adresses de retour ;
— dans le fonctionnement des calculatrices en notation polonaise inversée (explica-
tion, intérêt des calculatrices en NPL) ;
— dans le fonctionnement de Postscript (devenu PDF) ;
— pour avoir une fonctionnalité «annuler» dans un traitement de texte.
2 Spécification
Une structure de pile est un type de données pour lequel sont disponibles les opéra-
tions suivantes :
1. creer() crée et retourne une nouvelle pile, initialement vide (en anglais :
create()) ;
2. empiler(x, p) empile la valeur xsur la pile p(push(x, p)) ;
3. est_vide(p) retourne True si la pile est vide, False dans le cas contraire ( is_empty(p) ) ;
4. depiler(t) retourne la valeur située au sommet de la pile et l’enlève du sommet
de la pile (pop(p)). Provoque une erreur si la pile est vide.
On a aussi parfois une fonction sommet(p) retournant la valeur située au sommet de
la pile (top(p)).
3 Exercices
3.1 Chaînes bien parenthésées
On se donne une chaîne de caractère s , contenant divers caractères, dont possible-
ment (,),[et ].
On veut vérifier que cette chaîne est bien parenthésée.
Est définie comme «bien parenthésée» toute chaîne s vérifiant l’une des conditions
suivantes :
1. sne contient aucune parenthèse ni crochet ;
2. s commence respectivement par ( ou [ et finit respectivement par ) ou ] et
s[1:-1]est bien parenthésée ;
3. sest la concaténation de deux chaînes bien parenthésées.
Exemples :
Bien parenthésée "(salut)[comment [vas-((tu))]] ce matin ?"
Mal parenthésées "(salut]" et ")salut("
Écrire une fonction bienparenthesee(s) retournant True si s est bien parenthésée
et False sinon.
(on supposera qu’on dispose d’une structure de pile.)
2

3.2 Calculatrice en polonaise inversée
On veut simuler une calculatrice en polonaise inversée. On peut lui donner une
chaîne de caractères décrivant des calculs à effectuer, par exemple «3 2 5 + *», une pile
contenant déjà des valeurs, et elle retourne la pile après exécution des ordres donnés.
Pour simplifier, on considérera que les blancs sont obligatoires entre les arguments
ou fonctions demandées.
On veut pouvoir disposer des nombres flottants, des quatre opérations, de la mise à
la puissance et de la racine carrée (sqrt).
4 Implantation d’une pile
Nous avons spécifié ce qu’était une structure de pile. Reste à voir comment l’implanter,
c’est-à-dire la réaliser concrêtement.
4.1 Avec des tableaux statiques
On représente une pile par un tableau t . t[0] est la première valeur empilée, t[1]
la deuxième, etc.
Pour savoir quelle est la dernière, on garde le compte du nombre d’éléments du
tableau.
Conceptuellement, une pile sera donc un couple d’un tableau et du nombre de cases
utilisées dans ce tableau.
En Python : on veut pouvoir modifier le nombre d’éléments, donc on prendra un
tableau à deux composantes : la première sera un tableau, la seconde l’index :
TAILLE_MAX = 1000
def cree():
"""Crée une nouvelle pile"""
t=[None]*TAILLE_MAX
return (t, 0)
def est_vide(p):
"""Retourne True si la pile est vide, False sinon"""
return p[1]== 0
def empile(x, p):
"""Empile x sur la pile p.
Précondition : p est de taille au plus TAILLE_MAX-1."""
t=p[0]
i=p[1]
t[i] =x
p[1]=i+1
3

def depile(p):
"""Dépile le sommet de p et le retourne.
Précondition: p doit être non-vide."""
t=p[0]
i=p[1]
p[1]=i-1
return t[i-1]
Quelle est la complexité des opérations ?
NB : p[0] est le tableau des données alors que p[1] est la taille de la pile, ce qui ne
facilite pas la lecture du code.
En fait, en Python, on se débrouillerait pour que le nombre d’éléments puisse être
noté p.taille et le tableau p.donnees en utilisant des classes et des objets.
On définit une classe Pile, avec
— des attributs taille et donnees stockant respectivement le tableau des données
et la taille de la pille ;
— des méthodes est_vide , empile , depile effectuant les opérations de test, d’empi-
lement et de dépilement vues plus haut.
— une méthode spéciale __init__ pour créer une pile vide.
class Pile:
def __init__(self):
self.donnees =[None]*TAILLE_MAX
self.taille = 0
def est_vide(self):
return self.taille == 0
def empile(self, x):
self.donnees[self.taille] =x
self.taille += 1
def depile(self):
self.taille -= 1
return self.donnees[self.taille]
Après ces définitions, on peut utiliser la classe pile comme suit :
# création:
p=Pile()
# empiler une valeur :
p.empile(11)
# tester si la pile est vide :
p.est_vide()
# dépiler :
p.depile()
# on peut même accéder aux attributs de p :
p.donnees
p.taille = 0 # (on vide la pile)
4

4.2 Implantation avec des tableaux dynamiques
Python propose des tableaux dynamiques, c’est-à-dire des tableaux auxquels on peut
ajouter ou enlever des éléments.
On peut alors facilement construire une structure de pile
TAILLE_MAX = 1000
def cree():
"""Crée une nouvelle pile"""
return []
def est_vide(p):
"""Retourne True si la pile est vide, False sinon"""
return len(p) == 0
def empile(x, p):
"""Empile x sur la pile p."""
p.append(x)
def depile(p):
"""Dépile le sommet de p et le retourne."""
return p.pop()
Complexité des opérations ?
NB :
1. l’implantation sous forme de tableaux dynamiques est plus simple. . .
2. . . . car la difficulté est cachée dans l’implantation des tableaux dynamiques ;
3. elle sera privilégiée en Python puisque Python fournit des tableaux dynamiques ;
4. il faut connaître l’implantation avec tableaux statiques, plus simple dans les
langages sans tableaux statiques.
5 Exercice : percolation
5