Structure de pile

3
Structure de pile
¦Une structure de données en informatique combine un moyen d’enregistrer des données
sous une forme organisée et de les manipuler. En général, lorsque l’on définit une structure
de données, on en donne aussi une représentation (mathématique, graphique ou autre)
permettant de visualiser comment elle fonctionne. Jusqu’à présent, les structures de don-
nées que l’on a rencontré en PYTHON sont les listes (et les tuples) les matrices de NUMPY.
¦Lorsque l’on programme une sructure de données, il y a deux choses qui apparaissent :
• La mise en œuvre ou implémentation de cette structure ;
• La liste et le rôle des différentes opérations (primitives) qui sont fournies pour mani-
puler cette structure (c’est l’interface de la structure).
L’utilisateur de la structure de données ne doit connaitre que l’interface. Les détails de l’im-
plémentation n’ont pas à être connus (et peuvent éventuellement changer). L’interface per-
met de séparer l’utilisation de la structure de sa mise en œuvre.
¦La structure de données qui nous intéresse ici : les piles (stack ou LIFO pour last in first
out i.e. dernier entré premier sorti). On se représente une pile (informatique) comme une
pile d’assiettes : on peut ajouter des éléments et seul le dernier élément ajouté est directe-
ment accessible. Les primitives de manipulation sont :
•pile_vide() définit une nouvelle pile, ne contenant aucun élément ;
•empiler(P,x) modifie la pile Pen ajoutant l’élément xau sommet ;
•depiler(P) retire l’élément qui est au sommet de la pile et renvoie sa valeur (pro-
duit une erreur si la pile ne contient aucun élément);
•est_vide(P) renvoie True si la pile est vide et False sinon.
Exemple. On peut traiter un exemple sans savoir comment sont programmées ces fonc-
tions. On part par exemple d’une pile vide, on empile la valeur 12 puis la valeur −3, on
dépile ensuite l’élément qui se trouve au sommet :
P = pile_vide() empiler(P,12) empiler(P,-3) x = depiler(P)
P P
12
P
−3
12
P
12
print(x)
-3

Mise en œuvre de la structure de pile
¦On programme cette structure en PYTHON en utilisant des listes.
def pile_vide():
return []
def empiler(P,x):
P.append(x)
def est_vide(P):
return len(P)==0
La fonction dépiler est un peu plus complexe. On utilise la fonction pop qui renvoie le der-
nier élément de la liste et le retire. On ajoute également un test permettant de déclencher
une erreur si la liste est vide :
def depiler(P):
assert not est_vide(P), "La pile est vide"
x = P.pop()
return x
La commande assert c,steste si la condition cest vraie. Si c’est le cas, alors le programme
continue normalement, sinon une erreur est déclenchée et la chaîne de caractères sest
affichée.
Remarque. Pourquoi utiliser une pile (et pas une liste) ?
• Si un algorithme utilise une pile, alors il peut être programmé dans tout langage qui
dispose de cette structure.
• La structure de pile est plus simple à mettre en œuvre que la structure de liste.
• Les primitives de manipulation des piles ont une meilleure complexité que celles de
manipulation des listes.
• Des structures de piles peuvent être présente à un niveau assez bas dans la concep-
tion d’un ordinateur.
Quand vaut-il mieux utiliser une liste plutôt qu’une pile ?
• Quand on a besoin d’accéder à n’importe quel élément et pas seulement au dernier.
• Quand on a besoin d’ajouter ou supprimer des éléments à des positions quelconques.
• Quand on a besoin de connaitre le nombre d’éléments présents dans la structure. 
Exemple. On considère la suite (un) définie par
u0=2 et pour n∈N,un+1=2un−1. On veut
définir une fonction afficher(n) qui affiche
les valeurs de un,un−1,...,u1,u0dans cet ordre.
Le principe est le suivant :
• On crée une pile vide et on empile u0;
• L’élément uau sommet de la pile représente
un terme de la suite. On le dépile puis on le re-
met et on empile ensuite 2u−1 qui est le terme
suivant. On répète ceci nfois ;
• La pile contient alors u0,u1,...,un(dans cet
ordre). On dépile l’élément au sommet, on l’af-
fiche, puis on recommence tant que la pile n’est
pas vide.
def afficher(n):
P = pile_vide()
empiler(P,2)
for k in range(n):
u = depiler(P)
empiler(P,u)
empiler(P,2*u-1)
while not est_vide(P):
print(depiler(P))
afficher(8)
257 129 65 33 17 9 5 3 2