Département d’Informatique

Module I33 :
Structures de données
Prof : Badr HSSINA
badr.hssina@univh2c.ma
Parcours MIP (S3)
2019-2020
Pr. B.HSSINA badr.hssina@univh2c.ma Module I133:
Structures de données 1
 plan
 Structures linéaires
 Listes simplement chaînées
 Listes doublement chaînées
 Piles
 Files

Pr. B.HSSINA badr.hssina@univh2c.ma Module I133:

Structures de données 2
 Chapitre 4 : Les files

Pr. B.HSSINA badr.hssina@univh2c.ma Module I133:

Structures de données 3
 plan
 Définition d’une file
Utilisations
 Représentation d’une file
 Statique
 Dynamique
 Opérations
 Initialiser
 Empiler
 Dépiler
 Afficher
 Détruire

Pr. B.HSSINA badr.hssina@univh2c.ma Module I133:

Structures de données 4
 Définitions
 Une FILE (en anglais queue) est une structure de donnée dans laquelle
l’insertion se fait à la fin et la suppression d’un élément s’effectue à partir
du 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.

Pr. B.HSSINA badr.hssina@univh2c.ma Module I133:

Structures de données 5
 Définitions
 Principe : une loi FIFO First In First Out le premier arrivé est le premier servi

 L’action d’ajouter un nouvel élément s ’appelle Enfiler.

 L’action de retirer un élément situé au début de la file s’appelle Défiler.

 Exemple : file d’attente

 dans le bus

 des requêtes destinées à un serveur

Extraction Insertion

[0] [1] [2] [3] [4]

Pr. B.HSSINA badr.hssina@univh2c.ma Module I133:

Structures de données 6
 Utilisations
 Elle sont, en général utilisé pour mémoriser temporairement des transactions qui
doivent être 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èmes 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.
Pr. B.HSSINA badr.hssina@univh2c.ma Module I133:
Structures de données 7
 Représentation

 Différentes représentations
 Représentation statique
Un vecteur qui représente la FILE F[Max] avec av et
ar deux variables globales indiquant la tête et
la queue de la file.
Un enregistrement avec deux champs.
 Représentation dynamique
 Listes chaînées

Pr. B.HSSINA badr.hssina@univh2c.ma Module I133:

Structures de données 8
 - 1ère partie : Représentation statique -

Pr. B.HSSINA badr.hssina@univh2c.ma Module I133:

Structures de données 9
 Représentation
Représentation contiguë ( par tableau) :
 Les éléments de la file sont rangés dans un tableau qui représente la FILE
F[Max].
 av, ar deux variables globales de type entier indiquant la tête et la queue de
la file.

(1) (2) (3) (4)

C ar C ar
B
ar B B av
A av A av

ar
av
inserer(C) extraire(A)
Pr. B.HSSINA badr.hssina@univh2c.ma Module I133:
Structures de données 10
 Les opérations de base sur la File
 initialisation : la file est vide au départ

ar  0 et av  0

 insertion de l’élément x : F[ar]  x et ar  ar+1

 extraction de l’élément x : x <- F[av] et av <- av+1

 Problème : du fait que les deux variables av et ar sont toujours

incrémentées, on arrive à un Overflow (file pleine) même si la file
n’est pas saturée (voir (4) on ne peut pas insérer un autre
élément)

Pr. B.HSSINA badr.hssina@univh2c.ma Module I133:

Structures de données 11
 Les opérations de base sur la File
 une première solution serait de modifier extraire de sorte lorsqu’un élément
est défilé toute la file est passée vers l’avant.

 Si on ignore la possibilité d’un Underflow (file vide) l’opération s’écrit

x=F[i];
for (i=0; i<=ar-1; i++) F[i]= F[i+1];
ar=ar-1;

 Remarque : on n’a pas besoin dans ce cas de préciser la tête, elle est toujours au
début de la file

 Inconvénient : lorsqu’on a un tableau de grande taille, extraire un élément

nécessite le déplacement de tous les éléments du tableau.

Pr. B.HSSINA badr.hssina@univh2c.ma Module I133:

Structures de données 12
 Les opérations de base sur la File
 une seconde solution consiste à voir la FILE comme un ensemble circulaire d’éléments F[0],
F[1], F[2], …. F[n-1], F[0]

E indice=4 E E E E
D D D av=3
D D av=3 av=3

C av=2 C av=2 H indice=2

G indice=1
G
F indice=0 F F
F indice=0

inserer(F) extraire(A) inserer(G) inserer(H)

 il n ’y a pas perte de place, on exploite tout le tableau. On aura un Overflow lorsque ar+1=av
(dans cette représentation circulaire ar représente le nombre d’élément dans la file)

Pr. B.HSSINA badr.hssina@univh2c.ma Module I133:

Structures de données 13
 Les opérations de base sur la File
#include <stdio.h>
#define MAX 4
typedef struct{

int F[MAX];
int av;
int nb; // nombre d’élément dans la file

} TFile;

void initialiser(TFile *file) { file->av = 0; file->nb = 0; }

int filevide(TFile file) { return (file.nb == 0); }

int filepleine(TFile file) { return file.nb == MAX;}

Pr. B.HSSINA badr.hssina@univh2c.ma Module I133:
Structures de données 14
 Les opérations de base sur la File
void enfiler(TFile *file,int x)

if (filepleine(*file)) printf("Overflow, file pleine\n");

else { int indice;

indice = (file->av + file->nb) % MAX;

file->F[indice] = x;

file->nb++;

}
Pr. B.HSSINA badr.hssina@univh2c.ma Module I133:
Structures de données 15
 Les opérations de base sur la File
void defiler(TFile *file, int *obj)

if (filevide(*file)) printf("Underflow, file vide\n");

else { *obj =file->F[file->av];

file->av++;
if (file->av == MAX) file->av =0;
file->nb--;
}

Pr. B.HSSINA badr.hssina@univh2c.ma Module I133:

Structures de données 16
 - 2ème partie : Représentation dynamique -

Pr. B.HSSINA badr.hssina@univh2c.ma Module I133:

Structures de données 17
 Représentation chainée (par pointeurs)
 Identiquement aux piles, cette structure est basée sur les listes
chaînées.

 Les éléments de la file sont chaînés entre eux.

 Chaque élément de la file pointera vers l'élément suivant.

 La récupération (extraction) des données sera faite dans l'ordre

d'insertion

Pr. B.HSSINA badr.hssina@univh2c.ma Module I133:

Structures de données 18
 Représentation chainée (par pointeurs)
 L’implémentation d’une file est la même qu’une liste simplement chaînée avec la
règle suivante :

L'ajout d'un élément se fera à la fin (queue, arrière) de la liste (File) et le

retrait d'un élément se fera au début (avant, tête) de la liste (File)

Extraction
30 15 6 2 Insertion
debut fin

Pr. B.HSSINA badr.hssina@univh2c.ma Module I133:

Structures de données 19
 Représentation
 La structure de la file
 Nous allons créer une file d'entiers (int)
 notre file sera basée sur une liste chaînée (simple)
 On suppose que la file est déclarée de la façon suivante :

typedef struct element {

int info; /*La donnée que notre file stockera */

struct element * suivant; /*Pointeur vers l'élément suivant */

} Element;

Pr. B.HSSINA badr.hssina@univh2c.ma Module I133:

Structures de données 20
 Représentation
 Pour avoir le contrôle de la file, il est préférable de sauvegarder ces éléments :
• l’adresse du premier élément : Correspond au début de la file et il permet de
réaliser l'opération de suppression des données Element *debut

• l’adresse du dernier élément : correspond à la fin de la file et il permet de réaliser

l'opération d’insertion des données Element *fin

• le nombre d'éléments : int taille

 On suppose que la File est déclarée de la façon suivante :

typedef struct {

Element * debut; /*Pointeur vers le premier élément */

Element * fin; /*Pointeur vers le dernier élément */
int taille; /* la taille de la file , ce champ est facultatif*/
} File;

Pr. B.HSSINA badr.hssina@univh2c.ma Module I133:

Structures de données 21
 Opération de base sur les Files
 Initialisation
Prototype de la fonction : File * initialisation (File *F);

 Cette opération doit être faite avant toute autre opération sur la File.

 Elle initialise le pointeur debut et fin avec le pointeur NULL, et la taille avec la valeur 0.

Fonction
File * initialisation (File * F) {
F->debut = NULL;
F->fin = NULL;
F->taille = 0;
return F;
}

Pr. B.HSSINA badr.hssina@univh2c.ma Module I133:

Structures de données 22
 Opération de base sur les Files
 Insertion d'un nouvel élément (Enfiler)

Prototype de la fonction :
La fonction renvoie un pointeur de type File.

File * enfiler(File * F, int donnee);

Algorithme de la fonction :
 Déclaration d'élément(s) à insérer.
 Allocation de la mémoire pour le nouvel élément.
 Remplir le contenu du champ de données.
 Mettre à jour le pointeur debut vers le 1er élément (le début de la file).
 Mettre à jour le pointeur fin (ça nous servira pour l'insertion vers la fin de la file).
 Mettre à jour la taille de la file.

Pr. B.HSSINA badr.hssina@univh2c.ma Module I133:

Structures de données 23
 Opération de base sur les Files
 Insertion d'un nouvel élément (Enfiler)

fin
debut Nouveau_Element
(2) donnee
donnee donnee donnee donnee (1) suivant
suivant suivant suivant suivant
NULL

Pr. B.HSSINA badr.hssina@univh2c.ma Module I133:

Structures de données 24
 Opération de base sur les Files
 Insertion d'un nouvel élément (Enfiler)
File * enfiler(File * F, int donnee) {

Element *nouveau_element;
nouveau_element=AllouerNoued();
nouveau_element->info= donnee;

if (F->fin==NULL) { F->fin = nouveau_element;

F->debut = nouveau_element;}

else { F->fin->suivant = nouveau_element;

F->fin = nouveau_element; }

F->taille++;
return F;
}

Pr. B.HSSINA badr.hssina@univh2c.ma Module I133:

Structures de données 25
 Opération de base sur les Files
 Suppression d'un élément (Défiler)
 Pour supprimer l'élément de la file, il faut tout simplement supprimer
l'élément vers lequel pointe le pointeur debut
 Cette opération ne permet pas de récupérer la donnée au début de la file,
mais seulement de la supprimer.

Algorithme de la fonction :
 le pointeur supp_elem contiendra l'adresse du 1er élément (debut)
 le pointeur debut pointera vers le 2ème élément (après la suppression du 1er
élément, le 2ème sera au début de la file)
 la taille de la file sera décrémentée d'un élément

Pr. B.HSSINA badr.hssina@univh2c.ma Module I133:

Structures de données 26
 Opération de base sur les Files
 Suppression d'un élément (Défiler)

debut fin
(2)

donnee donnee donnee donnee

suivant suivant suivant suivant
NULL
(1)

Elem_supp

Pr. B.HSSINA badr.hssina@univh2c.ma Module I133:

Structures de données 27
 Opération de base sur les Files
 Suppression d'un élément (Défiler)
La fonction renvoie un pointeur de type File.

File * defiler (File * F) {

if (F->debut==NULL) return F;

else { Element * elem_supp;

elem_supp= F->debut;

if (F->taille == 1) {F->debut=NULL ; F->fin=NULL; }

else F->debut = F->debut->suivant;

free (elem_supp);

F->taille--; return F };

Pr. B.HSSINA badr.hssina@univh2c.ma Module I133:

Structures de données 28
 Opération de base sur les Files
 Affichage de la file

Algorithme de la fonction
 il faut se positionner au debut de la file
 En utilisant le pointeur suivant de chaque élément, la file est
parcourue du debut vers la fin
 La condition d'arrêt est donnée par la taille de la file
Fonction
void affiche (File * F) {
Element *courant; int i;
courant = F->debut;
for(i=1;i<=(F->taille);i++) {
printf(" %d\n", courant->info);
courant = courant->suivant; }
}
Pr. B.HSSINA badr.hssina@univh2c.ma Module I133:
Structures de données 29
 Opération de base sur les Files
 Vider la file

 Il s'agit d’une fonction permettant d'effacer la File

Algorithme de la fonction

Tant que le pointeur fin n'est pas NULL

Effacer le premier élément de la file

Fonction

File * file_clear(File *F) { while (F->fin != NULL) F=defiler(F); }

Pr. B.HSSINA badr.hssina@univh2c.ma Module I133:

Structures de données 30
 Récapitulatif : Pile vs File
Pile File
Les objets sont insérés et supprimés à la même Les objets sont insérés et retirés de 2 extrémités
extrémité. différentes.

Dans les piles, un seul pointeur est utilisé. Il Dans les files, deux pointeurs différents sont
pointe vers le haut de la pile. utilisés pour les extrémités; la tète et la fin.

Dans les piles, le dernier objet inséré est le Dans les files, l’objet inséré en premier est le
premier à sortir. premier qui sera supprimé.

Les piles suivent l’ordre Last In First Out (LIFO) Les files suivent l’ordre First In First Out (FIFO)

Les opérations de pile s’appellent Empiler et Les opérations de file sont appelées Enfiler et
Dépiler. Défiler.
Les piles sont visualisées sous forme de Les files sont visualisées sous forme de
collections verticales. collections horizontales.

Pr. B.HSSINA badr.hssina@univh2c.ma Module I133:

Structures de données 31