Langage C avancé

Tronc commun

Pr. Nabila ZRIRA & Pr. Hamza TOULNI

Département Informatique

Année universitaire: 2023-2024

Chapitre III
Piles et Files
Piles et Files
Définition

Les piles et les files constituent des structures de données.

Une pile permet de réaliser ce qu’on nomme une LIFO (Last In First Out) : les derniers éléments à être
ajoutés à la pile seront les premiers à être récupérés

Exemple : une pile d'assiette

Lorsqu’on ajoute une assiette en haut de la pile, on retire toujours en premier celle qui se trouve en
haut sinon tout le reste s'écroule.

3
Piles et Files
Définition

Une file permet de réaliser une FIFO (First In First Out) ce qui veut dire que les premiers éléments ajoutés à
la file, seront aussi les premiers à être récupérés.

Exemple : une file d‘attente

Lorsqu’une personne arrive, il est ajouté à la fin de la file (queue). La personne servie est la première
personne de la file (arrivée)
Les files peuvent être utilisées afin de mémoriser des données en attente de traitement.

4
Implémentation d’une pile

✓ Les données de la pile peuvent être de n’importe quel type ;

✓ La pile sera basée sur une liste chaînée (simple) ;
✓ Chaque élément de la pile pointera vers le maillon précédent ;
✓ La liste pointera toujours vers le sommet de la pile.

5
Implémentation d’une pile
Déclaration des variables
dernier
Syntaxe : Donnée

Donnée Précédent
typedef struct { Précédent
int donnee;
struct Maillon *precedent;
Donnée
} Maillon;
Précédent

typedef struct {
La pile n’est rien qu’un pointeur Donnée
Maillon *dernier; vers le dernier maillon de la liste
Précédent
}Pile;

6
Implémentation d’une pile
Initialisation de la pile
dernier

typedef struct {

Maillon *dernier;

}Pile;

void Initialiser_Pile (Pile *pile) {

pile->dernier=NULL;

7
Ajouter un élément à la pile
Empiler

Les piles sont un cas particulier des listes chaînées.

Dans une pile l’insertion d’un maillon se fait toujours en haut de la pile (au début de la liste).

dernier

20
43 29 Précédent
Précédent Précédent

Prototype de la fonction

void Empiler (Pile *pile, int valeur);

8
Ajouter un élément à la pile
Empiler

✓ On crée un nouveau maillon

✓ On vérifie que le maillon a bien été créé

✓ On assigne à la donnée du maillon, la valeur que l’on veut ajouter

✓ On fait pointer ce maillon sur le sommet de la pile

✓ On fait pointer le sommet de la pile sur ce maillon

9
Ajouter un élément à la pile
Empiler

void Empiler (Pile *pile, int valeur){

Maillon * nouveau_maillon;
nouveau_maillon=(Maillon *)malloc (sizeof(Maillon));

if (nouveau_maillon !=NULL) {
nouveau _maillon ->donnee=valeur;
nouveau _maillon ->precedent=pile->dernier;
pile->dernier=nouveau_maillon;
}
}

10
Retirer un élément de la pile
Dépiler

Le maillon qui sera retiré de la pile sera le dernier maillon que l'on a ajouté (l’élément se trouvant au
sommet de la pile).

dernier

20
13 27 Précédent
Précédent Précédent

Cette fonction modifiera directement la pile grâce à un pointeur.

Le prototype de la fonction :

int * Depiler(Pile *pile);

11
Retirer un élément de la pile
Dépiler

✓ Vérifier si la pile n'est pas vide

✓ Stocker dans un maillon temporaire l’avant dernier maillon de la pile
✓ Stocker dans une variable locale la valeur étant stockée dans le dernier de la pile
✓ Supprimer le dernier maillon
✓ Faire pointer la pile vers notre maillon temporaire

12
Retirer un élément de la pile
Dépiler

int * Depiler(Pile *pile){

Maillon *supprimer;
int * depile=NULL;
if (pile->dernier != NULL) {
depile=(int *)malloc(sizeof(int));
supprimer = pile->dernier;
(*depile) = pile->dernier->donnee;
pile->dernier = pile->dernier->precedent;
free(supprimer);
}
return depile;
}
13
Vider la pile

Il s'agit de la fonction permettant d'effacer la pile. Cette fonction se réalise en seulement deux étapes.

Le prototype de la fonction :

void Vider(Pile *p);

Algorithme de la fonction :

✓ Tant que la pile n'est pas nulle ;

✓ Effacer le dernier maillon de la pile grâce à la fonction Depiler().

void Vider_Pile(Pile *pile){

while(pile->dernier != NULL)
Depiler(pile);
}

14
Implémentation d’une file

Identiquement aux piles, cette structure sera basée sur les listes chaînées .
Cependant, cette fois-ci, on ne pointera plus sur le sommet mais sur la base de la file.
Nous utilisons un pointeur vers l'élément suivant et non plus vers l'élément précédent. Ceci s'explique par
le fait que nous pointons à la base de la file (sur le premier élément de la file)
Lors de l'ajout d'un élément, celui-ci se fera en fin de liste. Le retrait d'un élément se fera en début de

liste.

typedef struct{ Donnée

int donnee; Suivant
struct Maillon *suivant;
} Maillon;

15
Implémentation d’une file

typedef struct {
Maillon *premier;
}File;

premier
18
Suivant
34
42
Suivant
Suivant

16
Initialisation d’une file

void Initialiser_File (File *file) {

file->premier=NULL;
}

premier

17
Ajouter un élément à la file
Enfiler

L'ajout d’un maillon dans une file se fera à la fin de la file

17
premier
Suivant
18
Suivant
34
42
Suivant
Suivant

Le prototype de la fonction :

void Enfiler(File *file, int valeur);

18
Ajouter un élément à la file
Enfiler

Algorithme de la fonction Enfiler() :

✓ On crée un nouveau maillon
✓ On vérifie que le nouveau maillon a bien été créé
✓ On fait pointer ce maillon vers NULL
✓ On assigne à la donnée de ce maillon, la donnée que l'on veut ajouter
✓ Si la file est nulle, alors on fait pointer la file vers ce maillon
✓ Sinon, on crée un maillon temporaire
✓ On parcourt entièrement la file
✓ On fait pointer le maillon temporaire vers le nouvel maillon créé

19
Ajouter un élément à la file
Enfiler
void Enfiler (File *file, int valeur) {
Maillon * nouveau_maillon;
Maillon *courant;
nouveau_maillon=(Maillon *)malloc(sizeof(Maillon));
if (nouveau_maillon!=NULL){
nouveau_maillon->donnee=valeur;
nouveau_maillon->suivant=NULL;
if (file->premier!=NULL) {
courant=file->premier;
while (courant->suivant!=NULL)
courant=courant->suivant;
courant->suivant=nouveau_maillon;
} else
file->premier=nouveau_maillon;
}
}
20
Retirer un élément de la file
Défiler
L’élément qui sera enlevé sera le premier élément de la file.

17
premier
Suivant
18
Suivant
34
42
Suivant
Suivant

21
Retirer un élément de la file
Défiler
Le maillon qui sera enlevé sera le premier maillon de la file.

int * Defiler (File *file) {

Maillon * supprimer;
int * defile=NULL;
if (file->premier !=NULL){
defile=(int *)malloc(sizeof(int));
supprimer = file->premier;
(*defile)=file->premier->donnee;
file->premier = file->premier->suivant;
free(supprimer);
}
return defile;
} 22
Vider la file

Il s’agit de la fonction permettant d’effacer la file. Cette fonction se réalise en seulement deux étapes.
✓ Tant que la file n’est pas vide ;
✓ Effacer le dernier élément de la file grâce à la fonction Défiler.

void Vider_File(File *file) {

while (file->premier !=NULL)
Defiler(file);
}

23
Conclusion

✓ Les piles et les files permettent d'organiser en mémoire des données qui arrivent au fur et à mesure.
✓ Elles utilisent un système de liste chaînée pour assembler les éléments.
✓ Dans le cas des piles, les données s'ajoutent les unes au-dessus des autres. Lorsqu'on extrait une
donnée, on récupère la dernière qui vient d'être ajoutée (la plus récente). On parle d'algorithme LIFO
pour "Last In First Out".
✓ Dans le cas des files, les données s'ajoutent les unes à la suite des autres. On extrait la première
donnée à avoir été ajoutée dans la file (la plus ancienne). On parle d'algorithme FIFO pour "First In
First Out".

24