Piles et Files

(1)

19/03/2020

1

Piles et Files

1

(2)

19/03/2020

2

Piles

• Une pile ( stack) est une séquence ordonnée

d'éléments dans laquelle tous les ajouts et toutes les suppressions se font à une extrémité

(sommet de pile).

• Le dernier arrivé est le premier servi ( LIFO - last in first out).

2

(3)

19/03/2020

3

• LES OPERATIONS DE BASE SUR LES PILES

• *Empiler: rajouter un nouvel élément au sommet de la pile

• *Dépiler: supprimer l’élément qui se trouve au sommet de la pile.

• *Sommetpile : renvoie la valeur de l’élément du sommet de la pile.

3

(4)

19/03/2020

4

LES OPERATIONS DE BASE SUR LES PILES

• On peut définir d’autres primitives qui facilitent l’utilisation d’une pile.

• *Deux prédicats qui permettent de tester les sur et sous dépassements de la pile :

est_vide et pile_pleine.

• *Une fonction pile_vide pour initialiser une pile.

4

(5)

19/03/2020

5

TAD: Pile

• Nom Pile (Element)

• Utilise Element, boolean

• Opérations

• PileVide :  Pile

• Empiler : Pile × Element  Pile

• EstVide : Pile  boolean

• Dépiler : Pile  Pile

• Sommet : Pile  Element

5

(6)

19/03/2020

6

• Préconditions

• Dépiler(p) et Sommet(p) définies ssi la pile est non-vide .

• Axiomes

• EstVide(PileVide()) = vrai

• EstVide(Empiler(p, e)) = faux

• Dépiler(Empiler(p, e)) = p

• Sommet(Empiler(p, e)) = e

6

(7)

19/03/2020

7

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

7

(8)

19/03/2020

8

Piles : représentation contiguë

• La pile sera représentée par un tableau pile, dont la taille maximale est dim_pile. L’accès au premier élément est déterminé par un indice sommet.

• Pile représentée par

• un tableau

• un indice représentant le sommet

• Les deux éléments sont inclus dans une structure

8

(9)

19/03/2020

9

Réalisation d'une Pile Contiguë

• #define dim_pile 25

• Typedef int element ;

• typedef struct { element Elements[dim_pile];

• int sommet;

• } pile;

• int pile_pleine(pile p)

• {

• return(p.sommet==dim_pile-1);

• }

9

(10)

19/03/2020

10

• int est_vide(pile p)

• {

• return(p.sommet==-1);

• }

• pile pile_vide()

• {

• pile p;

• p.sommet=-1;

• return p;

• }

10

(11)

19/03/2020

11

• pile empiler(pile p, element e)

• {

• if (pile_pleine(p))

• erreur(« pile pleine »);

• ((p).sommet)++;

• ((p).Elements)[(p).sommet]=e;

• return p;

• }

11

(12)

19/03/2020

12

• pile depiler(pile p)

• {

• if(!est_vide(p))

• {

• (p).sommet)--;return p;

• }

• erreur(« pile vide »);

• }

element somet(pile p)

• {

• if(!est_vide(p) return (p.Elements)[p.sommet];

• erreur(« pile vide »);

• }

12

(13)

19/03/2020

13

FILES

• Une file est une séquence ordonnée d'éléments dans laquelle tous les ajouts se font à une

extrémité (queue de file) et toutes les

suppressions se font à l’autre extrémité (tête de file).

• Le premier arrivé est le premier servi ( FIFO - first in first out).

13

(14)

19/03/2020

14

• LES OPERATIONS DE BASE SUR LES FILES

• *Enfiler: rajouter un nouvel élément à la file

• *Défiler: supprimer l’élément qui se trouve en tête de la file.

• *head : renvoie la valeur de l’élément qui se trouve en tête de la file.

14

(15)

19/03/2020

15

LES OPERATIONS DE BASE SUR LES FILES

• On peut définir d’autres primitives qui facilitent l’utilisation d’une file.

• *Deux prédicats qui permettent de tester les sur et sous dépassements de la file :

est_vide et file_pleine.

• *Une fonction file_vide pour initialiser une file.

15

(16)

19/03/2020

16

• Une pile : ajout et retrait du même côté (sommet).

• Une file : ajout à la fin et retrait au début

16

(17)

19/03/2020

17

TAD FILE

• Nom File (Element)

• Utilise Element, boolean

• Opérations

• file_vide : File

• enfiler : File × Element  File

• est_vide : File  boolean

• défiler : File  File

• Head : File  Element

(18)

19/03/2020

18

• Préconditions

• Défiler et head ne sont définies que si file n’est pas vide

• Axiomes

• Est_vide(FileVide()) = vrai

• Est_vide(enfiler(f , e)) = faux

• head(enfiler(file_vide(), e)) = e

• head(enfiler(f , e)) = head(f ) si f non vide

• Défiler(enfiler(file_vide(), e)) = file_vide()

• Défiler(enfiler(f , e)) = enfiler(Défiler(f ), e) si f non vide

(19)

19/03/2020

19

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

(20)

19/03/2020

20

Files : représentation contiguë

• structure:

• un tableau t(de dimension n_max) représente les valeurs

• un entier représente la position de la tête de la File.

• un entier représente la position de la queue de la File.

(21)

19/03/2020

21

Une première représentation par tableau simple

• Initialisation: tete=0; queue=-1;

• File est vide si tete>queue

• File est pleine si queue=n_max-1;

• Enfiler: queue++; t[queue]=e

• Defiler: tete++

• Inconvénient : on ne peut plus ajouter des éléments dans la file, alors qu'elle n'est pas pleine !

21

(22)

19/03/2020

22

• Une solution: décaler les éléments de la file vers la gauche à chaque suppression.

• Tete toujours égale à 0

• Initialisation: queue=-1

• File est vide si queue =-1

• défiler: décalage à gauche de tous les éléments de la file.

• Enfiler: queue++; t[queue]=e

22

(23)

19/03/2020

23

Représentation Contiguë d'une File (Par tableau circulaire)

• Gérer le tableau de manière circulaire : suivant de l'élément à la position ⁱ est l'élément à la position

(i+1) modulo n_max

23

(24)

19/03/2020

24

Réalisation d'une File Contiguë Circulaire

#define n_max 50

/* taille maximale d'une file */

typedef int Element;

/* les éléments sont des int */

typedef struct {

Element t[n_max];

/* les éléments de la file */

int tete;

/* position précédant premier élément */

int queue;

/* position dernier élément */

int nb_elets;//nombre d’éléments de t

} File; ₂₄

(25)

19/03/2020

25

Réalisation d'une File Contiguë Circulaire

• int plusun(int i){

• if(i==n_max-1)return 0;

• return(i+1);

• }

• File file_vide(){

• File F;

• F.tete=0;

• F.queue=n_max-1;

• F.nb_elets=0;

• return F;

• }

25

(26)

19/03/2020

26

int est_vide(File f) {

if (f.nb_elets == 0) return 1;

return 0;

}

int est_pleine(File f){

if(f.nb_elets==n_max)return 1;

return 0;

}

26

(27)

19/03/2020

27

Element head(File f) { if (est_vide(f))

erreur("Erreur: file vide !\n");

return (f.t)[f.tete];

}

27

(28)

19/03/2020

28

File enfiler(File f, Element e) { if (est_pleine(f))

erreur("Erreur : file pleine !\n");

f.queue= plusun(f.queue);

(f.t)[f.queue] = e;

(f.nb_elets)++;

return f;

}

28

(29)

19/03/2020

29

File defiler(File f) { if (est_vide(f))

erreur("Erreur: file vide !\n");

f.tete=plusun(f.tete);

(f.nb_elets)--;

return f;

}

29

(30)

19/03/2020

30

File chaînée

• typedef struct {

• liste tete;

• place queue;

• } File;

30