Organisation des données et structures de stockage

Dimension: px

Commencer à balayer dès la page:

Download "Organisation des données et structures de stockage"

Victoire Viau
il y a 8 ans
Total affichages :

1 ING2 - ING3 Nvx Organisation des données et structures de stockage IV. Structures linéaires : les files et les piles. Les files et les piles sont des listes d'éléments organisées selon l'odre d'arrivée des éléments. Dans une file, le premier élément ajouté sera le premier traîté (et supprimé) : une file repose sur le principe FIFO (first-in, first-out). A l'inverse, dans une pile, c'est le dernier entré qui est le premier sorti : une pile repose sur le principe LIFO (last-in, first-out). A un instant donné, un seul élément est accessible : dans une file, c'est le plus "ancien" (le premier à y avoir été inséré) ; dans une pile, c'est le plus "récent" (le dernier à y avoir été inséré). Les seules opérations pouvant être effectuées sur les files et les piles sont : - Création - Tests de file/pile vide ou pleine - Ajout d un élément - Suppression d un élément Les files et les piles peuvent être implémentées par tableaux ou par listes chaînées. Dans les deux cas, les opérations d'insertion et de suppression sont rapides et ne dépendent pas de la taille des données. Du point de vue optimisation mémoire, l'utilisation d'une liste chaînée est préférable si le nombre d'éléments présents à un instant donné dans la file ou dans la pile peut devenir grand et présenter des variations importantes. Julienne Palasi Page 1 29/11/09

Dans une file, le premier élément ajouté sera le premier traîté (et supprimé) : une file repose sur le principe FIFO (first-in, first-out).

2 A. Les files 1. Déition Une file, comme son nom l indique, respecte le principe des files d attente : les éléments sont traîtés les uns après les autres, dans l ordre de leur arrivée. Le premier élément enfilé (ajouté dans la file) est le premier à être défilé (sorti de la file). On dit qu une file est une liste FIFO : first-in, first-out. 2. Applications Parmi les nombreuses utilisations et applications des files, on retrouve bien entendu tous les problèmes liés à la gestion de files d attente : - Simulations de files d attente aux caisses d un magasin, aux guichets d une administration, à un péage autoroutier... pour étudier les délais d attente, minimiser les coûts - Gestion de trafic aérien - Gestion d une file d impression - Synchronisation des accés à des ressources partagées - Gestion des évènements en programmation temps réel 3. Implémentation des files a. Implémentation par tableau circulaire sortie 0 entrée Nmax Figure 1 : Les files : implémentation par tableau circulaire Julienne Palasi Page 2 29/11/09

Applications Parmi les nombreuses utilisations et applications des files, on retrouve bien entendu tous les problèmes liés à la gestion de files d attente : - Simulations de files d attente aux

3 Après l enfilement de 3 éléments : sortie tête entrée 0 Nmax Après le défilement de 1 élément : tête 0 Après l enfilement de 4 éléments et le défilement de 3 éléments : tête = Nmax 0 Au fur et à mesure des enfilements et des défilements, le début du tableau se libère, et le bloc des cases occupées se décale vers la du tableau. Au bout d un moment, on atteint la dernière case du tableau. Mais la file n est pas forcément pleine pour autant! Solution : utiliser un tableau circulaire. Si la dernière case est atteinte, on revient en début de tableau ( =%Nmax) Après l enfilement de 2 éléments : tête 0 Figure 2 : enfilement et défilement des éléments Julienne Palasi Page 3 29/11/09

Au bout d un moment, on atteint la dernière case du tableau. Mais la file n est pas forcément pleine pour autant! Solution : utiliser un tableau circulaire.

4 Comment tester si la file est vide ou pleine? Si les indices de tête et de sont égaux, la file peut être pleine ou vide. Les deux cas ne peuvent être différencier. Une solution serait de considérer la file pleine dés que Nmax-1 cases sont occupées. Une autre solution est tout simplement de mémoriser la taille de la file. Structure pour une file générique implémentée par tableau ciculaire : //taille maximum de la file #dee Nmax 10 // structure file typedef struct file{ void * tab[nmax] ; // tableau de pointeurs génériques int tete, ; int taille ; )t_file ; //opérations sur les files //création t_file * créer_file() ; //test file vide int file_vide(t_file * f) ; //test file pleine int file_pleine(t_file * f) ; //enfiler un élément (pointeur générique sur la donnée) void enfiler(t_file * f, void * data) ; //défiler : retourne un pointeur générique (sur la donnée) void * defiler(t_file * f) ; file_tab.h Julienne Palasi Page 4 29/11/09

Structure pour une file générique implémentée par tableau ciculaire : //taille maximum de la file #dee Nmax 10 // structure file typedef struct file{ void * tab[nmax] ; // tableau de pointeurs

5 Opérations sur les files : #include file_tab.h //création d unefile vide t_file * créer_file(){ t_file * f ; f=(t_file * )malloc(sizeof(t_file)) ; f->tete=f->=0 ; f->taille=0 ; return f ; //test file vide int file_vide(t_file * f){ ; //test file pleine int file_pleine(t_file * f){ return (f->taille==nmax) ; //enfiler un élément (pointeur générique sur la donnée) void enfiler(t_file * f, void * data) { if(file_pleine( f ). ; else{ f->tab[f->]=data ; f->=(f-> + 1) % Nmax ; f->taille ++ ; //défiler : retourne un pointeur générique (sur la donnée) void * defiler(t_file * f) { void *x = NULL ; if(file_vide( f ). ; else{ x=f->tab[f->tete] ; f->tete=(f->tete + 1) % Nmax ; f->taille -- ; return x ; file_tab.c Julienne Palasi Page 5 29/11/09

$f){ ; //test file pleine int file_pleine(t_file * f){ return (f->taille==nmax) ; //enfiler un élément (pointeur générique sur la donnée) void enfiler(t_file * f, void * data) {$

6 Exemple d utilisation : enfiler puis défiler les 10 premiers entiers #include file_tab.h int main(){ int i ; int *p ; t_file *f ; //création de la file f=creer_file() ; // enfilement des 10 premiers entiers for(i=0 ;i<10 ;i++){ p=(int * )malloc(sizeof(int)) ; *p = i ; enfiler(f, (void * )p) ; // défilement et afffichage for(i=0 ; i<10 ; i++){ p= (int*) defiler( f ) ; printf( %d\t,*p) ; free(p) ; free(f) ; Exemple 1 : enfiler puis défiler en les affichant les 10 premiers entiers Julienne Palasi Page 6 29/11/09

$i++){ p= (int*) defiler( f ) ; printf( %d\t,*p) ; free(p) ; free(f) ; Exemple 1 : enfiler puis défiler en les affichant les 10$

7 b. Implémentation par liste chaînée Selon le principe FIFO, l ajout et la suppression se font du coté opposé. On utilisera donc une liste chaînée à double ancrage. Une liste simplement chaînée suffit si l ajout est fait en de liste et la suppression en tête. suppression ajout tete Figure 3 : Les files : implémentation par liste chaînée Structure pour une file générique implémentée par liste chaînée : // structure pour un maillon typedef struct s_ maillon{ void * data; struct s_maillon * suivant ; )t_maillon ; // structure pour la file typedef struct file{ t_maillon * tete ; t_maillon * ; )t_file ; //opérations sur les files file.h Opérations sur les files : Julienne Palasi Page 7 29/11/09

$typedef struct s_ maillon{ void * data; struct s_maillon * suivant ; )t_maillon ; // structure pour la file typedef struct file{ t_maillon * tete ; t_maillon * ; )t_file ;$

8 2 tete 3 1 temp Figure 4 : défilement (suppression en tête) tete 1 2 Figure 5 : enfilement (ajout en ) Julienne Palasi Page 8 29/11/09

9 #include file.h t_file * creer_file(){ t_file * f ; f=(t_file * )malloc(sizeof(t_file)) ; f->tete=f->=null ; return f ; int file_vide( t_file * f){ if (f->tete==null) return 1; else return 0; void enfiler (t_file *f, void * data){ t_maillon * nouv; //création du nouveau maillon nouv=creer_maillon(data); //accrochage if (file_vide()) f->tete=f->=nouv; else{ f->->suivant=nouv; f->=nouv; void * defiler( t_file * f){ t_maillon * temp ; void* x =NULL ; if (file_vide(f) ) ; else{ temp=f->tete ; x = temp->data ; if (f->tete = = f->) f->tete=f->=null ; // si un seul élément else f->tete=f->tete->suivant ; free (temp) ; return x ; file.c Julienne Palasi Page 9 29/11/09

$else return 0; void enfiler (t_file *f, void * data){ t_maillon * nouv; //création du nouveau maillon nouv=creer_maillon(data); //accrochage if (file_vide())$

10 B. Les piles 1. Déition Le principe est le même que celui d une pile d assiettes. C est la dernière lavée et empilée qui sera la première dépilée et séchée. Dans une pile, les éléments sont traîtés les uns après les autres, dans l ordre inverse de leur arrivée. On dit qu une pile est une liste LIFO : last-in, first-out. 2. Implémentation des piles a. Implémentation par tableau entrée sortie Nmax h : sommet (hauteur) de la pile Figure 6 : les piles : implémentation par tableau //taille maximum de la pile #dee Nmax 10 // structure pile typedef struct pile{ void * tab[nmax] ; // tableau de pointeurs génériques int hauteur ; )t_pile ; //opérations sur les piles t_file * créer_pile() ; int pile_vide(t_pile * p) ; int pile _pleine(t_pile * p) ; void empiler(t_pile * p, void * data) ; void * depiler(t_pile * p) ; pile_tab.h Julienne Palasi Page 10 29/11/09

$struct pile{ void * tab[nmax] ; // tableau de pointeurs génériques int hauteur ; )t_pile ; //opérations sur les piles t_file * créer_pile() ; int pile_vide(t_pile * p) ; int pile _pleine(t_pile * p)$

11 b. Implémentation par liste chaînée Selon le principe LIFO, l ajout et la suppression se font du même coté. On utilisera donc une liste simplement chaînée avec ajout et suppression en tête de liste. suppression ajout tete Figure 7 : les piles : implémentation par liste chaînée 3. Exemples d applications a. Evaluation d expressions arithmétiques b. Appel de procédures et récursivité c. Casse-tête : les tours de Hanoi Julienne Palasi Page 11 29/11/09

suppression ajout tete Figure 7 : les piles : implémentation par liste chaînée 3. Exemples d applications a.

Documents pareils

T. A. D. pile. Chapitre 7 (suite) Listes particulières. T. A. D. file. représentation chaînée de la file algorithmique. Files

T. A. D. pile. Chapitre 7 (suite) Listes particulières. T. A. D. file. représentation chaînée de la file algorithmique. Files Chapitre 7 (suite) Listes particulières Pile : liste particulière T. A. D. pile insertion et suppression au sommet de la pile extraction Files queue Listes doublement chaînées insertion file : liste particulière