A) Introduction

Une pile est une liste dans laquelle les insertions et les
suppressions se font à une seule et même extrémité appelée le
sommet de la pile. Une pile suit le principe "du dernier
arrivé, premier sorti" en anglais LIFO (Last In First Out).

Les opérations de base

créer une pile vide
déterminer si une pile est vide
déterminer si une pile est pleine
empiler un élément sur une pile
dépiler l'élément qui se trouve au sommet d'une pile
 B) La représentation par tableau

Dans ce type de représentation, le nombre d'éléments pouvant être

conservés dans la pile sera limité par la taille du tableau.

Le type utilisé sera le suivant :

type unePile : article

sesDonnées : tableau [1..N] de unElément ;
sonSommet : entier ;
fin unPile

Les données contenues dans la pile sont insérées dans un tableau (champ
sesDonnées de l'article).

L'indice du sommet de la pile est un entier appartenant à l'intervalle [0 .. N]

(champ sonSommet de l'article). La pile est vide quand sonSommet = 0,
pour insérer un élément, on incrémente sonSommet puis on insère l'élément
(à l'indice sonSommet). La pile est pleine quand sonSommet = N.
1) procédure créationPileVide (R pile : unePile)
// création de pile : une pile vide

début pile.sonSommet := 0 ;
fin créationPileVide

2) fonction pileVide (V pile : unePile) retourne booléen

// la fonction retourne VRAI si pile est une pile vide et FAUX sinon

début retourne pile. sonSommet = 0 ;

fin pileVide

3) fonction pilePleine (V pile : unePile) retourne booléen

// la fonction retourne VRAI si pile est une pile pleine et FAUX sinon

début retourne pile. sonSommet = N ;

fin pileVide
4) procédure empiler (V élément : unElément; R pile : unePile;
R erreur : booléen)

// la procédure empile élément sur pile,

// sauf si pile est déjà pleine auquel cas
// le booléen erreur est mis à VRAI

début si pilePleine (pile)

alors erreur := VRAI ;
sinon erreur := FAUX ;
//on incrémente d’abord sonSommet
pile. sonSommet := pile. sonSommet + 1 ;
//on empile ensuite élément
pile.sesDonnées [pile. sonSommet ] := élément ;
fsi ;
fin empiler
5) procédure dépiler (R pile : unePile; Rerreur : booléen;
Rélément : unElément)
// la procédure dépile pile, et retourne l’élément dépilé dans élément
// sauf si pile est déjà vide auquel cas
// le booléen erreur est mis à VRAI

début si pileVide (pile)

alors erreur := VRAI ;
sinon erreur := FAUX ;
//on récupère d’abord élément
élément := pile. sesDonnées [pile. sonSommet ] ;
//on décrémente ensuite sonSommet
pile. sonSommet := pile. sonSommet - 1 ;
fsi
fin dépiler
 C) la représentation par liste chaînées
Dans cette représentation, le nombre d'éléments pouvant être mis dans la pile
n'est pas limité par la structure de la pile, il n’est limité que par la taille de la
mémoire.

Les types utilisés sont les suivants :

type unePile : ^uneCellule

uneCellule : article
saDonnée : unElément ;
sonSuivant : unePile ; // ou ^uneCellule
fin uneCellule

Chaque donnée de la pile est contenue dans une cellule de la liste chaînée,
la cellule. Soit laPile une variable de type unePile, laPile est vide quand
laPile = NIL, et pour insérer un élément dans laPile on construit une nouvelle
cellule (appel de la procédure nouveau), puis on place cette nouvelle cellule en
tête de laPile.
1) procédure créationPileVide (R pile : unePile)
// création de pile : une pile vide
début pile := NIL ;
fin créationPileVide

2) fonction pileVide (V pile : unePile) retourne booléen

//la fonction retourne VRAI si pile est une pile vide

début retourne (pile = NIL) ;

fin pileVide

3) fonction pilePleine (V pile : unePile) retourne booléen

//la fonction retourne VRAI si pile est une pile pleine

début retourne FAUX ;

fin pilePleine
4) procédure empiler (V élément : unElément; R pile : unePile;
R erreur : booléen)

// la procédure empile élément sur pile,

// sauf si pile est déjà pleine auquel cas
// le booléen erreur est mis à VRAI

aux pNouv : unePile ;

début nouveau (pNouv) ;

erreur := FAUX ;
pNouv ^.saDonnée := élément ;
pNouv ^.sonSuivant := pile ;
pile := pNouv ;
fin empiler
5) procédure dépiler (R pile : unePile ; R erreur : booléen ;
R élément : unElément)

// la procédure dépile pile, et retourne l’élément dépilé dans élément

// sauf si pile est déjà vide auquel cas le booléen erreur est mis à
VRAI

début si pileVide (pile) = NIL

alors erreur := VRAI ;
sinon erreur := FAUX ;
élément := pile^.saDonnée ;
pile := pile^.sonSuivant
fsi
fin dépiler
 D) Exemple

Évaluation d'une expression post-fixée à l'aide d'une pile.

La notation postfixée de l'expression arithmétique (A*B)/(C+D) est : A B * C

D + /. On souhaite écrire un algorithme qui prendra en entrée une expression
de cette forme, et retournera le résultat de son évaluation.

Pour coder l'expression post-fixée, on utilise un tableau expression où

expression[i] contient le ième caractère de l'expression. La fin de
l'expression est marquée dans le tableau par le caractère spécial #.

Pour évaluer l'expression :

• on lit le tableau de gauche à droite
• quand le caractère lu est une variable, on empile sa valeur
• quand le caractère lu est un opérateur, on dépile son ou ses
opérandes, on calcule le résultat et on l'empile
• quand on arrive au caractère #, la pile contient pour seul élément
le résultat de l'évaluation