Cours langage C ; Piles et files

1. Structures de données
1
Piles et Files
En utilisant les listes chainées
Prof. M. Khalifa MANSOURI
Université Hassan II de Casablanca
ENSET de Mohammedia
Département Mathématiques et Informatique

2. Structures de données
1. Les piles
2

3. Les piles
3
Une pile (stack en anglais) est une structure dynamique dans
laquelle l'insertion ou la suppression d'un élément s‘effectue
toujours à partir de la même extrémité de cette structure.
Cette extrémité est appelée le sommet de la pile.
Définition

4. Les piles
4
Une pile permet de modéliser un système régi par
le mécanisme « dernier arrivé premier sorti » :
(Lifo : last in, first out).
Principe de LIFO
• L'action pour ajouter un nouvel élément au sommet de la
pile s'appelle Empiler
• L’action pour retirer l‘élément situé au sommet de
la pile s'appelle Dépiler

5. Les application des piles
5
De nombreuse applications s'appuient sur l'utilisation d'une pile, on peut citer :
• 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.
• Vérification de parenthèse d'une chaine de caractères ;
• La récursivité (une fonction qui fait appel a elle même) ;
• etc.…
Utilisation

6. Les application des piles
6
Ajouter dans cet ordre
A EB D FCA B C D E F
Pile
Exemple de Pile (1)

7. Les application des piles
7
A
B
C
D
E
F
Pile
Exemple de Pile (2)

8. Les application des piles
8

9. Les application des piles
9

10. Implémentation d’une pile
1
Représentation d'une Pile
Représentation contiguë (par tableau) :
Les éléments de la pile sont rangés dans un tableau
Un entier représente la position du sommet de la pile
Représentation chaînée (par pointeurs) :
Les éléments de la pile sont chaînés entre eux
Un pointeur sur le premier élément désigne la pile et
représente le sommet de cette pile
Une pile vide est représentée par le pointeur NULL

11. Implémentation d’une pile
1
On peut implémenter une pile à l’aide de la même structuration qu’une liste chainée
e1 e2 e3 e4@ @ @ NULL
*P
@

12. Implémentation d’une pile
1
Pile chaînée
p
Pile
10 20
50
Sommet de la pile
pointée par p
Cellule contenant la
valeur 5
Pointeur sur cellule
suivante
Pointeur
NULL

13. Implémentation d’une pile
1
Syntaxe pour définir la structure de la pile
//Définir la structure cellule
typedef struct Element
{
int info ; //le champ info peut avoir n'importe quel type
struct Element *suiv ; //pointeur contenant l'adresse de l’élément suivant
} Element;
Déclaration d’une pile
Element pile; // En utilisant une variable statique
Element *pile; // En utilisant une variable dynamique

14. Opérations sur une pile
1
Voici les primitives communément utilisées :
1. Element *PileVide() : créer une pile vide
2. int EstVide(Element *p) : renvoie vrai si la pile est vide, faux sinon ;
3. Type Sommet(Element *p) : renvoie l‘élément sommet de type Type
de la pile P ;
4. Element* Empiler(Element *p,Type v) : ajoute au sommet de la pile
P l’élément v de type Type;
5. Element* Depiler(Element *P) : supprime de la pile P le sommet.

15. Implémentation d’une pile
1
Element PileVide()
Element PileVide()
{
return(NULL) ;
}

16. Implémentation d’une pile
1
int EstVide()
int EstVide(Element *pile)
{
if(pile==NULL)
return (1) ;
else
return (0) ;
}
Dans la suite on considère que Type est entier

17. Implémentation d’une pile
1
sommet(P)
int sommet(Element *p)
{
if(p==NULL)
printf("pile vide!");
else
return p->info;
}

18. Implémentation d’une pile
1
Element empiler()
Element Empiler(Element *P,int v)
{
Element *nouv ;
nouv =(Element*)malloc(sizeof(Element)) ;
nouv ->info=v ;
nouv ->suiv=p ;
return(nouv) ;
}

19. Implémentation d’une pile
1
Element depiler(Element *p)
Element Depiler(Element *P)
{
Element *c = p ;
if(c==NULL)
return(NULL) ;
else
{
p = p -> suiv ;
free(c) ;
return(p) ;
}
}

20. Structures de données
2. Les files
2

21. Les Files
2
Une File (queue en anglais ) est une structure de données
dans laquelle l'insertion se fait à la fin et la suppression d'un
élément s'effectue à partir de début de cette structure.
Le fonctionnement ressemble à une file d'attente : les
premières personnes arrivées, se sont les premières
personnes à servir.
Définition

22. Les files
2
Une file permet de modéliser un système régi par le
mécanisme "premier arrivé premier sorti" ; on dit souvent
FIFO (First in, First out)
Principe de FIFO
•L'action pour ajouter un nouvel élément s'appelle Enfiler
•L'action pour retirer l‘élément situe au début de la File
s'appelle Défiler

23. Les application des files
2

24. Les application des files
2
Ajouter dans cet ordre
A EB D FCA B C D E F
Exemple de File (1)
Fil
e

25. Les application des files
2
A EB D FC
Exemple de File (2)
File

26. Les application des files
2
• En général, on utilise des files pour mémoriser temporairement des transactions qui
doivent attendre pour être traitées ;
• Les serveurs d'impression, qui doivent traiter les requêtes dans l'ordre dans lequel
elles arrivent, et les insèrent dans une file d'attente ( ou une queue) ;
• Certains moteurs multitâches, dans un système d'exploitation, qui doivent accorder
du temps-machine a 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.…
Utilisation

27. Les application des files
2

28. Les application des files
2

29. Les application des files
2
Représentation d'une File
Représentation contiguë (par tableau) :
Les éléments de la file sont rangés dans un tableau
Deux entiers représentent respectivement les
positions de la tête et de la queue de la file
Représentation chaînée (par pointeurs) :
Les éléments de la file sont chaînés entre eux
Un pointeur sur le premier élément désigne la file
et représente la tête de cette file
Un pointeur sur le dernier élément représente la
queue de file
Une file vide est représentée par le pointeur NULL

30. Implémentation d’une file
3
On peut implémenter une file à l’aide de la même structuration qu’une
liste chainée
e1 e2 e3 e4@ @ @ NULL
*premier
@
*dernier
@
Et on mémorise le premier et le dernier élément

31. Les application des files
3
File chaînée
tete
File
10 20
50
Tête de la file pointée par
tete
Cellule contenant la
valeur 30
Pointeur sur cellule
suivante
Pointeur
NULLqueue
Queue de file pointée
par queue

32. Implémentation d’une File
3
Syntaxe pour définir la structure de la File
//Définir la structure cellule
typedef struct Element
{
int info ; //le champ info peut avoir n'importe quel type
struct Element *suiv ; //pointeur contenant l'adresse de l’élément suivant
} Element;
//Définir la structure File
typedef struct File
{
Element *premier;
Element *dernier;
} File;

33. Implémentation d’une file
3
Déclaration d’une file
File file; // En utilisant une variable statique
File *file; // En utilisant une variable dynamique

34. Opérations sur une file
3
Voici les primitives communément utilisées :
1. File FileVide(File F) : créer une file vide
2. int EstVide(File F) : renvoie vrai si la file est vide, faux sinon ;
3. Type PremierElement(File F) : renvoie le premier élément de type
Type de la File F;
4. File Emfiler(File F,Type v) : ajoute à la fin de la file F l’élément v de
type Type;
5. File Defiler(File F) : supprime de la file F le premier élément.

35. Implémentation d’une file
3
File FileVide()
File FileVide()
{
File F ;
F.premier = NULL ; ;
F.Dernier = NULL ;
return(F) ;
}

36. Implémentation d’une file
3
int EstVide()
int EstVide(File F)
{
if(F.premier==NULL)
return (1) ;
else
return (0) ;
}
Dans la suite on considère que Type est entier

37. Implémentation d’une file
3
int premierElement(File F)
int premierElement(File F)
{
if(Estvide(F)
printf("file vide!");
else
return F.premier->info;
}

38. Implémentation d’une file
3
Emfiler()
File Emfiler(File F,int v)
{
Element *nouv ;
nouv =(Element*)malloc(sizeof(Element)) ;
nouv ->info=v ;
nouv ->suiv=NULL ;
If Estvide(F)
{
F.premier=nouv;
F.dernier=nouv;
}
else
{
F.dernier->suivant=nouv;
F.dernier=nouv;
}
return(F) ;
}

39. Implémentation d’une file
3
Element defiler(File F)
File Defiler(File F)
{
Element *c;
If estvide(F)
{
Printf("file vide!");
return(NULL) ;
}
else
{
c=F->premier ;
F->premier=F->premier->suivant;
free(c) ;
return(F) ;
}
}