Module: ALGORITHMIQUE 2

Chapitre 2: Piles et Files

Niveau: 1A
Equipe ALGO

Année universitaire:
2023/2024

1
Objectifs Spécifiques

À la fin de ce chapitre, l’étudiant sera capable de :

• Comprendre le type pile

• Manipuler une pile en respectant le principe LIFO (Last In First Out), en appliquant les
Opérations : empiler, dépiler, premier_pile, pile_vide et intialiser_pile
• Comprendre le type file
• Manipuler une file en respectant le principe FIFO (First In First Out), en appliquant les
Opérations: enfiler, défiler, premier_file, file_vide et intialiser_file
2
Plan

⮚ Introduction
⮚ Définition et déclaration des piles
⮚ Manipulation d’une pile
⮚ Définition et déclaration des files
⮚ Manipulation d’une file

2
 Introduction

• Les notions de pile et de file sont deux stratégies de manipulation des structures de
données regroupant un ensemble de données tel que les tableaux et les listes chaînées.

• Les piles et les files ne sont pas de nouveaux types de données mais plutôt une
manière de gérer un ensemble de données.

• Elles sont très souvent utiles et servent, entre autres, à mémoriser des évènements en
attente de traitement.
2
PARTIE I
Les piles
 Motivation
Les listes simplement chaînées (LS) sont des structures de données qui:
- n'exigent pas une contiguïté des éléments à stocker en mémoire.
- organisent une série de données en mémoire en les liant entre elles à l'aide de pointeurs.

Premier Élément Dernier Élément

(tête de la liste) (pointe vers NULL)

⇨La représentation chaînée des listes est coûteuse par les parcours!
⇨Pensons à éviter ce parcours?!
 Motivation

Exemple 1:

Une pile d’assiettes qu’il faut manipuler

avec attention pour éviter les dégâts.

Afin de gérer une pile d’assiettes, il faut suivre les règles suivantes:
1. Toute nouvelle assiette est ajoutée en haut de la pile.
2. Le retrait d’une assiette fournit celle qui a été posée en dernier.
3. Le dernier élément posé sur la pile est le premier à en sortir.
2
 Motivation

Exemple 2:

Manipuler une pile de livres.

Imaginez que vous avez un ensemble de livres entassés l’un sur l’autre, pour pouvoir retirer un
livre il faut retirer tous les livres qui sont entassés en dessus!

⇨ Comment définir une pile en algorithmique ?!

 Définition

• Une pile est une variante un peu particulière des listes simplement chaînées.

• Une pile (stack) est une liste dans laquelle l'insertion ou la suppression d'un
élément s'effectue toujours à partir de la même extrémité de la liste,
appelée début ou tête ou sommet de la pile.

• Une pile permet de modéliser un système régi par la discipline « dernier

arrivé -premier sorti »
2
 Définition
⇨ On dit souvent qu'il s'agit d'un un traitement LIFO (last in, first out).

• L'action consistant à ajouter un

nouvel élément au sommet de la
pile s'appelle empiler.

• L'action consistant à retirer

l'élément situé au sommet de la
pile s'appelle dépiler.

• La hauteur de la pile est son nombre

d’éléments
2
 Déclaration
Une pile est définie par son sommet, c’est une liste simplement chaînée dont chaque élément est
constitué de:
* Un champ de données
* Un pointeur vers l’élément suivant de la pile

Syntaxe

Type
<nom_element> = Enregistrement
<champ_1>: <type_1>
…
<suivant_pointeur> :* <nom_ element >
FinEnregistrement

<nom_Pile> = *<nom_ element >

 Déclaration
Exemple

Type
Element = Enregistrement
P
val: entier 9
suivant :* Element
FinEnregistrement 25

10
Pile = * Element
Var
P: Pile
 Opérations de base

1. Création et initialisation d’une pile

2. Accès au sommet

3. Test : vérifier si la pile passée en paramètre est vide ou non.

4. Ajout au sommet (empiler): ajouter un élément sur la pile

5. Suppression du sommet (dépiler): retirer un élément de la pile et le renvoyer.

 Création et initialisation

Une pile est représentée par son sommet, qui est l'adresse de son premier
élément.

Fonction Initialisation ( ) : Pile

Début
Initialisation ←NULL
Fin
 Tester si une Pile est vide
Si le sommet pointe vers NULL c'est que la pile est vide:

Fonction Pile_Vide_V1( P : Pile ):entier

Début Fonction Pile_Vide_V2(P : Pile) : Booléen
Si ( P= Null) alors
Pile_vide_V1 ← 1 Début
Sinon
Pile_Vide_V2← (P = Null)
Pile_vide_V1 ← 0
Finsi Fin
Fin
 Accès au Sommet

La pile pointe toujours vers son premier élément : l’élément le plus accessible.
Fonction Consulter_sommet( P : Pile): entier
Début
Si (Non(Pile_Vide_V2(P)))alors
Consulter_sommet ← *P.val
Sinon
écrire(‘la pile est vide!’)
Consulter_sommet ← -1
Finsi
Fin

⇨ La représentation chaînée des listes était coûteuse par les parcours mais dans le cas
des piles, on ne fait pas de parcours, on n’accède qu’au sommet.
 Empiler: Ajouter un élément au Sommet de la pile

L’ajout d’une valeur à une pile revient à une insertion au début de la liste si on considère que le
sommet est la tête de la liste.

Étapes d’ajout d’un élément à la pile:

1. Création d’une structure en réservant l’espace mémoire nécessaire.

2. Mise à jour du champ val et du champ suivant (chaînage avec l’ancien sommet) du
nouvel élément.

3. Modification du pointeur du sommet avec l’adresse du nouvel élément.

 Empiler: Ajouter un élément au Sommet de la pile

L’ajout d’une valeur à une pile revient à une insertion en début de liste si l’on considère
que le sommet est la tête de la liste.

Fonction Empiler( P : Pile, X : Entier) : Pile

Var nouv: *Element
Début
nouv ← allouer(taille(Element))
*nouv .val ← X
*nouv .Suivant ← P
P← nouv
Empiler ← P
Fin
 Dépiler : Retirer un élément du Sommet de la pile

L'élément à dépiler correspond obligatoirement au dernier ajouté qui se trouve au

sommet de la pile!

Étapes de retrait d’un élément de la pile :

1. Tester si la pile est vide ou non
2. Si elle n’est pas vide
a. pointer vers le Sommet par SUPP et sauvegarder la valeur X qui existe au
sommet de la pile
b. mettre à jour le sommet de la pile
c. libérer SUPP
3. Sinon, un message d’erreur sera affiché
 Dépiler : Retirer un élément du Sommet de la pile

La suppression d’une valeur dans une pile (non vide) revient à effectuer une suppression d’un élément (le
premier élément de la liste) et à retourner la donnée enregistrée dans X.

Fonction Dépiler ( P : Pile, X: *entier) : Pile

Var Supp: *Element
Début
Si (Pile_Vide_V2(P) <> Faux) alors
Supp ← P
*X ← *Supp.val
P ← *Supp.Suivant
Libérer(Supp)
Finsi
Dépiler ← P
Fin
PARTIE II
Les files
 Motivation
Si vous avez besoin du dernier élément de votre LS et vous allez effectuer plusieurs mises à
jour sur la fin de votre liste:

⇨ Peut-on identifier la fin de la liste dans sa définition sans avoir besoin de chercher le dernier
à chaque fois ?!!

Exemple:

Une file d’attente devant le guichet de

la municipalité, chacun à son tour
qu’il doit respecter.

⇨ Comment définir une file en algorithmique ?!

 Définition
Une file est un ensemble de valeurs (de même type) qui a un début (Tête) et une fin (Queue).

Une file est une structure de données basée sur le principe «Premier entré, premier sorti».

⇨ On dit souvent qu'il s'agit d'un

traitement FIFO (First In, First Out).

⇨ Les premiers éléments ajoutés à la file

seront les premiers à être récupérer.
 Déclaration

Une file est une structure où les insertions se font en queue et les suppressions en tête.

Les seuls éléments accessibles dans une file sont le premier élément pour la récupération qui est la
tête et le dernier élément pour l’ajout qui est la queue.

Une file est une liste chaînée définie par sa Tête et son Queue.

Chaque élément de la file est constitué de:

* Un champ de données
* Un pointeur vers l’élément suivant de la file
 Déclaration
Syntaxe
Type
<nom_element> = Enregistrement
<champ_1>: <type_1>
…
<suivant_pointeur> :* <nom_element>
FinEnregistrement

<nom_File> = Enregistrement
<nom_Tete> : *<nom_element>
<nom_Queue> : *<nom_element>
FinEnregistrement
 Déclaration
Exemple F.Tete F.Queue
Type
Element = Enregistrement
val: entier
suivant : *Element
FinEnregistrement
5 15 9 20
File = Enregistrement
Tete : *Element
Queue : *Element F
FinEnregistrement
Var
F: File
 Manipulation d’une file

Du point de vue manipulation des files, les contraintes d’accès sont matérialisées par les
procédures et les fonctions suivantes :

● Init_File : pour créer une file vide

● File_Vide: pour vérifier si r la File est vide ou non
● Enfiler: pour ajouter l’élément x à la fin de la file (insertion en queue)
● Défiler: pour retirer le sommet de la file (suppression en tête) .
 Création et initialisation

Procédure Init_File(F: *File)

Début
*F.Tete←NULL
*F.Queue←NULL
Fin
 Tester si la file est vide

Fonction File_vide( F: File):booléen

Début

File_vide ← (F.Tete=NULL) & (F.Queue=NULL)

Fin
 Consulter Tête

La fonction consulter_tete permet de retourner la tête de la file

Fonction consulter_tete( F : File): entier

Début
Si (Non(File_vide( F ))) alors
Consulter_tete ← *(F.Tete).valeur
Finsi
Fin
 Enfiler: ajouter un élément à une file

L'opération d’ajout d’un élément à une file est une insertion en queue dans une LS.

Étapes :

1. Allocation du nouvel élément

1. Affectation de la nouvelle valeur et champs suivant pointe vers NULL

1. Tester si la file est vide ou non:

a. Si la file est vide, le pointeur Tete et le pointeur Queue pointent vers le nouvel élément
b. Sinon, le dernier élément va pointer vers le nouvel élément et mise à jour du pointeur Queue
 Enfiler: ajouter un élément à une file
Fonction Enfiler( F : File , X : Entier) : File
Variable nouv : *Element
Début
nouv ← Allouer(taille(Element))
(*nouv) .Val ← X
(*nouv) .Suivant ← NULL
Si (File_vide(F)) Alors // si la file est vide
F.Tete ← nouv
Sinon
*(F.Queue).Suivant← nouv
Fin Si
F.Queue ← nouv
Enfiler ← F
Fin
 Défiler : retirer un élément de la file

L'opération de suppression d’un élément d’une file est une suppression en tête dans une LS.
Il s’agit de supprimer le premier de la liste et retourner la donnée supprimée.

Étapes :
1. Tester si la file est vide : un message d’erreur sera affiché

1. Si la file n’est pas vide:

- effectuer une suppression en tête
- récupérer la valeur supprimée dans X
- cas particulier si la file contient au début un seul élément: mise à jour de la queue
- libérer l’ancienne tête
 Défiler : retirer un élément d’une file (non vide)

fonction Défiler( F : File, X:*entier) : File

Var supp : *Element
Début
Si (File_vide(F) <> faux) alors
supp ← F.tete
*X ← *supp.Val
F.tete← *supp.Suivant
Si (F.tete = NULL) alors // si la file contient un seul élément
F.Queue ← NULL
Finsi
Libérer(supp)
Finsi
Défiler← F
Fin