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 données que l’on a rencontré en P YTHON sont les listes (et les tuples) les matrices de N UMPY.
¦ 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 manipuler 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’implémentation n’ont pas à être connus (et peuvent éventuellement changer). L’interface permet 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 directement accessible. Les primitives de manipulation sont :
• pile_vide() définit une nouvelle pile, ne contenant aucun élément ;
• empiler(P,x) modifie la pile P en ajoutant l’élément x au sommet ;
• depiler(P) retire l’élément qui est au sommet de la pile et renvoie sa valeur (produit 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 fonctions. 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)
12
P
P
x = depiler(P)
−3
12
P
12
P
print(x)
-3
Mise en œuvre de la structure de pile
¦ On programme cette structure en P YTHON 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 dernier é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, s teste si la condition c est 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 s est
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 conception 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 (u n ) définie par
u 0 = 2 et pour n ∈ N, u n+1 = 2u n − 1. On veut
définir une fonction afficher(n) qui affiche
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)
les valeurs de u n , u n−1 , . . . , u 1 , u 0 dans cet ordre.
Le principe est le suivant :
• On crée une pile vide et on empile u 0 ;
• L’élément u au sommet de la pile représente
un terme de la suite. On le dépile puis on le remet et on empile ensuite 2u − 1 qui est le terme
suivant. On répète ceci n fois ;
• La pile contient alors u 0 , u 1 , . . . , u n (dans cet
ordre). On dépile l’élément au sommet, on l’af- 257 129 65 33 17 9 5 3 2
fiche, puis on recommence tant que la pile n’est
pas vide.