ASD : Algorithmique et Structures de données II Année universitaire 2009-2010

1LARS

LES PILES & LES FILES

Les piles et les files constituent des structures de données. Ces structures de données, vont,
comme leurs noms l'indiquent, nous permettre de stocker diverses données, comme pourrait le
faire un tableau.
I. Les Piles
1. Introduction & définition
Une pile permet de réaliser ce que l'on nomme une LIFO (Last In First Out- dernier arrivé,
premier servi) ce qui signifie en clair que les derniers éléments à être ajoutés à la pile seront
les premiers à êtres récupérés. Il est possible de comparer ceci à une pile d'assiette. Lorsque
l'on ajoute une assiette en haut de la pile, on retire toujours en premier celle qui se trouve en
haut de la pile c'est à dire celle qui a été ajoutée en dernier, sinon tout le reste s'écroule.
Les piles peuvent être utilisées pour sauvegarder temporairement des informations en
respectant leur ordre d'entrée, et les réutiliser en ordre inverse. Elles peuvent intervenir dans
de nombreux problèmes informatiques :
• Les algorithmes d'évaluation d'expressions mathématiques.
• Les algorithmes à essais successifs reposent fréquemment sur la récursivité et ont
besoin de sauvegarder la situation avant un essai pour pouvoir y revenir. Cette
sauvegarde s'effectue dans une pile puisque tout retour en arrière doit ramener à la
situation la plus récente.
Les opérations de mise à jour (insertion comme suppression) n'ont lieu qu'au sommet de la
pile :
• L’opération d’Ajout est appelée empiler : (insertion en tête).
• L’opération de suppression est appelée dépiler (suppression en tête).

2. Représentation et implémentation d’une pile

L’implémentation d’une pile peut se faire soit d’une façon statique (tableau) ou dynamique
(une liste chaînée).
1
ASD : Algorithmique et Structures de données II Année universitaire 2009-2010
1LARS

Remarque: Il est facile d’implémenter une pile au moyen d’un tableau. La seule difficulté
dans cette implémentation est la gestion des débordements de pile qui interviennent quand on
tente d’effecteur l’opération Dépiler sur une pile vide et l’opération Empiler sur un tableau
codant la pile qui est déjà plein.
Ce dernier problème n’apparaît pas lorsqu’on implémente les piles au moyen d’une structure
de données dont la taille n’est pas fixée a priori (comme une liste chaînée).
3. Déclaration
La déclaration d’une pile avec une implémentation chaînée est la même qu’une liste
simplement chaînée.
Type
TypeElem = <type>

Cellule = Enregistrement
Valeur : TypeElem
Suiv : ^Cellule
FinEnregistreement

Pile = ^ Cellule

4. Opérations de base sur les Piles

• Procédure Init (var P : Pile)

Initialise P à vide (NIL).
• Fonction Pile_Vide (P : Pile) : Booléen

VRAI si et seulement si P est vide.
• Fonction Sommet (P : Pile) : TypeElem

Retourne le premier élément de P.
• Procédure Empiler (Var P : Pile, X : TypeElem)

Place x dans P comme premier élément
• Procédure Dépiler (Var P : Pile, var E : TypeElem)

Retourne le premier élément de P dans E et supprime celui-ci de P.

Procédure Init (var P : Pile)

Début
P←NIL
Fin
***************************************************
2
ASD : Algorithmique et Structures de données II Année universitaire 2009-2010
1LARS

Fonction Pile_Vide (P : Pile) : booléen

Début
si (P = nil) alors
Est-Videvrai
sinon
Est-Videfaux
finsi
Fin
***************************************************
Fonction Sommet (P : Pile) : TypeElem
Début
Retourner (P^.valeur)
Fin
***************************************************
Procédure Empiler (var P : Pile, X: TypeElem)
Var
Nouveau : Pile
Début
Allouer (nouveau)
Nouveau^.valeur ←X
Nouveau ^.suivant← P
P ←Nouveau
Fin
***************************************************
Procédure Dépiler (var P : Pile, var E : TypeElem)
Var
Parcours : Pile
Début
Si (Non vide(P)) alors
Parcours←P
P←P^.suiv
E←Parcours^.valeur
Libérer (Parcours)
FinSi
Fin

3
ASD : Algorithmique et Structures de données II Année universitaire 2009-2010
1LARS

II. Les Files

1. Introduction & définition
Une file permet de réaliser une FIFO (First In First Out- premier entré, premier sorti) ce qui
veut dire que les premiers éléments ajoutés à la file, seront aussi les premiers à être récupérés.
Une file se comporte exactement comme une file d’attente de la vie courante.
Les files peuvent être utilisées afin de mémoriser des données en attente de traitement.

• L’opération d’Ajout est appelée enfiler : (insertion en fin de file)

• L’opération de suppression est appelée défiler (suppression en tête de file)

2. Représentation et implémentation d’une File

L’implémentation d’une pile peut se faire soit d’une façon statique (tableau) ou dynamique
(une liste chaînée).
Remarque: La seule difficulté dans la première implémentation est la gestion des
débordements de file qui interviennent quand on tente d’effectuer l’opération Défiler sur une
File vide et l’opération Enfiler sur un tableau plein. Ce dernier problème n’apparaît pas
lorsque l’on implémente les files au moyen d’une structure de donnée dont la taille n’est pas
fixée a priori (comme une liste chaînée simple ou doublement chaînée pour accélérer l’accès).

3. Déclaration
La déclaration d’une file avec une implémentation chaînée est similaire à une :
• Liste simple (si l’implémentation est simplement chaînée).
• Liste double (si l’implémentation est doublement chaînée).
4. Opérations de base sur les Files
• Procédure Init( var F : File) : Initialise F à vide.
• Fonction Vide_File (F: File) : booléen : VRAI ssi F est vide.
• Procédure Enfiler (x :TypeElem, var F: File) : place x dans F comme dernier élément.
• Procédure Défiler (var x : TypeElem, var F: File) : retourne le premier élément de F
dans x et supprime celui-ci de F.