Les Piles Et Les Files
Les Piles Et Les Files
Les Piles Et Les Files
les files
Table des
matières
I - 1- Les Piles 3
II - Application 1 : 5
III - 2- Files 7
IV - Application 2 : 10
1- Les Piles
1- Les Piles
I
Définition : 1.1- Définition
Une pile est une liste chaînée d'informations dans laquelle :
Il s'agit donc d'une structure de type LIFO (Last In First Out) Traduction : « Le dernier élément qui a été ajouté
est le premier à sortir ».
On ne travaille que sur le sommet de la pile. Les éléments de la pile sont reliés entre eux à la manière d'une liste
chaînée. Ils possèdent un pointeur vers l'élément suivant.
- Dans un navigateur web, une pile sert à mémoriser les pages Web visitées. L'adresse de chaque nouvelle page
visitée est empilée et l'utilisateur dépile l'adresse de la page précédente en cliquant le bouton « Afficher la
page précédente ».
- L'évaluation des expressions mathématiques en notation post fixée (ou polonaise inverse) utilise une pile.
- La fonction « Annuler la frappe » (en anglais « Undo ») d'un traitement de texte mémorise les modifications
apportées au texte dans une pile.
- Un algorithme de recherche en profondeur utilise une pile pour mémoriser les nœuds visités.
- Les algorithmes récursifs admis par certains langages (LISP, Algol, Pascal, C, etc.) utilisent implicitement une
pile d'appel. Dans un langage non récursif (FORTRAN par exemple), on peut donc toujours simuler la
récursion en créant les primitives de gestion d'une pile.
3
1- Les Piles
age : entier
Suivant : Pile
FinStructure
1.2.1- Empiler
Procedure Empiler ({E/S} T : Pile, {E} Valeur : entier ) //********** Ajout d'un élément dans une pile passée
en paramètre
Var
Début
P^.age ← Valeur //*********** stocke dans l'Info de l'élément pointé par P la valeur passée en paramètre
Fin
1.2.2- Dépiler
Procedure Dépiler ({E/S} T : Pile) //********** Suppression de l'élément au sommet de la pile passée en
paramètre
var
P : Pile //***************** Pointeur nécessaire pour libérer la place occupée par l'élément dépilé
Début
SI T <> nil alors //*********************** la pile n'est pas vide donc on peut dépiler
T ← T^.Suivant //*************** P va pointer sur le 2ème élément de la pile qui devient le sommet
Désallouer(P)
Finsi
Fin
4
Application 1 :
Application 1 :
II
Exercice
5
Application 1 :
Exercice
Énoncé :
Réalise une pile etudiant composée des champs matricule,nom et prenoms en faisant appelle à une procédure
empiler. Avant tout créer d'abord la pile etudiant avec les champs ci-dessus.
Solution :
etudiant =
FinStructure
Var
Pil :
Début
Allouer(Pil)
← mat
← nom
← pre
← Te
Te ← Pe
Fin
6
2- Files
2- Files
III
2.1- Définition
Une file est une liste chaînée d'informations qui est basée sur une structure de données basée sur le principe «
Premier entré, premier sorti », en anglais FIFO (First In, First Out), ce qui veut dire que les premiers éléments
ajoutés à la file seront les premiers à être récupérés.
Le fonctionnement ressemble à une file d'attente : les premières personnes à arriver sont les premières
personnes à sortir de la file.
Une file est comparable à une queue de clients à la caisse d'un magasin.
Les files servent à traiter les données dans l'ordre où on les a reçues et permettent de :
- gérer des processus en attente d'une ressource système (par exemple la liste des travaux à éditer sur une
imprimante)
- certains moteurs multitâches, dans un système d'exploitation, qui doivent accorder du temps-machine à
chaque tâche, sans en privilégier aucune.
- un algorithme de parcours en largeur utilise une file pour mémoriser les nœuds visités.
- on utilise aussi des files pour créer toutes sortes de mémoires tampons (en anglais buffers).
- etc.
Pour ne pas avoir à parcourir toute la liste au moment d'ajouter un élément en queue, on maintient un pointeur
de queue. Attention une file peut très bien être simplement chaînée même s'il y a un pointeur de queue.
Le pointeur de tête pointe sur le premier élément de la file, et le pointeur de queue sur le dernier. Il faut
commencer par définir un type de variable pour chaque élément de la file. La déclaration est identique à celle
d'une liste chaînée.
age : entier
Suivant : File
7
2- Files
FinStructure
2.2.1- Enfiler
Enfiler un élément consiste à l'ajouter en queue de liste. Il faut envisager le cas particulier où la file était vide.
En effet, dans ce cas, le pointeur de tête doit être modifié.
Procedure Enfiler ({E/S} T,Q : File, {E} Valeur : entier) //***************** Ajout d'un élément dans une
file( T pour la tête de la file et Q pour la queue de la file)
var
Début
P^.age ← Valeur //************************ stocke la valeur dans l'Info de l'élément pointé par P
P^.Suivant ← nil //*****************stocke nil (ce sera le dernier de la file) dans Suivant
Finsi
Fin
2.2.2- Défiler
Défiler est équivalent à dépiler et consiste à supprimer l'élément de tête si la file n'est pas vide. Si la file a un
seul élément, il faut mettre à jour le pointeur de queue car on vide la file. Il faut conserver l'adresse de l'élément
qu'on supprime pour libérer sa place.
Procedure Defiler ({E/S} T,Q : File, {S} Valeur : entier) //************** Suppression de l'élément de tête de
la file passée en paramètre
var
Début
Si T<> nil alors //********************** la liste n'est pas vide donc on peut défiler
T ← T^.Suivant //*********** P va pointer sur le 2ème élément de la pile qui devient le sommet
Desallouer(P)
8
2- Files
Si T = nil alors
Finsi
Finsi
Fin
9
Application 2 :
Application 2 :
IV
10
Application 2 :
Exercice
Énoncé :
Réalise une FILE etudiant composée des champs matricule,nom et prenoms en faisant appelle à une procédure
enfiler. Avant tout créer d'abord la pile etudiant avec les champs ci-dessus.
Solution
etudiant =
FinStructure
Type File =
var
Début
Allouer(F)
← mat
← nom
← pre
← nil
Si Te = nil alors
Sinon
← F
Finsi
←F
Fin
11