Chapitre 3 structures séquentielles

CHAPITRE III:

STRUCTURES SÉQUENTIELLES

Université Saad Dahlab – Blida1

Faculté des Sciences

Département d’Informatique

Licence d’Informatique

Semestre 3 (2ème année)

Algorithmique et Structures de Données

Mme AROUSSI

2016-2017

Disponible sur https://sites.google.com/a/esi.dz/s-aroussi/

PLAN DU CHAPITRE III

I. Introduction

II. Listes Linéaires Chaînées (LLC)

III. Files d’Attente (FIFO)

IV. Piles (LIFO)

2

3

� Une structure séquentielle est un ensemble de variables

de même nature organisées séquentiellement auxquelles

on peut accéder :

� soit directement par leur numéro d’ordre

� soit en les parcourant une par une dans l’ordre

INTRODUCTION

Structures séquentielles

Listes linéaires contigües

Tableaux

Fichiers séquentiels

Listes chaînées Structures séquentielles particulières

Files

Piles

PARTIE I:

LISTES LINÉAIRES CHAÎNÉES

(LLC)

PLAN DE LA PARTIE I

� Définitions

� Modèle des LLC (MLLC)

� Algorithmes sur les listes

� Listes particulières

� Représentation contigüe

� Conclusion

5

6

� Une Liste Linéaire Chaînées (LLC) est un ensemble de

maillons reliés entre eux.

� Un maillon est une entité renfermant de l’information et ayant

un pointeur sur le maillon qui la suit. C’est toujours une

structure (enregistrement) avec deux champs :

� un champ Valeur : contenant l'information

� un champ Suivant : donnant l'adresse du prochain maillon.

DÉFINITIONS

…….

val suiv

V1 @1 V2 @2 V3 @3 Vn @n

Nil

7

� Une LLC est caractérisée par :

� L'adresse de son premier élément (la tête de liste). Elle doit

toujours être sauvegardée dans une variable pour pouvoir

manipuler la liste.

� NIL constitue l'adresse qui ne pointe aucun maillon (indiquant

par convention la fin de la liste).

� Si la liste est vide (ne contient aucun maillon), la tête doit alors

être positionnée à NIL.

DÉFINITIONS

Tête de liste

…….

val suiv

V1 @1 V2 @2 V3 @3 Vn @n

Tête

Nil

8

DÉFINITIONS

Tête de liste

…….

val suiv

V1 @1 V2 @2 V3 @3 Vn @n

Langage

Algorithmique

Langage C

type Maillon = Structure

val : typeqq

suiv: * Maillon

fin

struct Maillon {

typeqq val ;

struct Maillon*suiv ;

};

Typedef struct Maillon {

typeqq val ;

struct Maillon*suiv ;

} Maillon;

Var Tête: *Maillon struct Maillon* Tête; Maillon* Tête;

où typeqq est un type simple (entier, réel, caractère, ...) ou

composé (tableau, chaîne de caractère, structure, …..)

9

� On définit un ensemble d'opérations que l'on va utiliser pour écrire

des algorithmes sur les listes. Cet ensemble d'opérations s'appelle le

Modèle des Listes Linéaires Chaînées (MLLC) :

MODÈLE DE LLC (MLLC)

Modules Rôle

Allouer( P)C’est une procédure qui alloue (dynamiquement) un nouveaumaillon et affecte son adresse dans le pointeur P.

Libérer(P) C’est une procédure qui détruit le maillon pointé par P.

Valeur(P)C’est une fonction qui retourne le contenu du champs « val » dumaillon pointé par P (retourner (*P.val))

Suivant(P)C’est une fonction qui retourne le contenu du champs « suiv » dumaillon pointé par P (retourner (*P.adr))

Aff_Suiv(P, Q)C’est une procédure qui affecte le pointeur Q dans le champs «suiv » du maillon pointé par P (*P.suiv←←←←Q)

Aff_Val(P,v)C’est une procédure qui affecte la valeur v dans le champs « val »

du maillon pointé par P (*P.val←←←←v)

10

� Voici l’équivalence en langage C, des fonctions et des procédures du

modèle :

MODÈLE DE LLC (MLLC)

Modules Implémentation en langage C

Allouer( P)struct Maillon *Allouer ( )

{ return ((struct Maillon *) malloc( sizeof(struct Maillon))); }

Libérer(P)Void Libérer ( struct Maillon *P)

{free (p);}

Valeur(P)typeqq Valeur( struct Maillon *P)

{ return( P->val) ; //équivalent à *P.val}

Suivant(P)struct Maillon *Suivant( struct Maillon *P)

{ return( P->suiv ); //équivalent à *P.suiv}}

Aff_Suiv(P, Qvoid aff_suiv( struct Maillon *P, struct Maillon *Q)

{ P->suiv = Q; //équivalent à *P.suiv=Q}

Aff_Val(P,v)void Aff_Val(struct Maillon *P, int v)

{ P->val =v; //équivalent à *P.val = v}

11

� Parcours :

� Accès par valeur : il s'agit de rechercher (séquentiellement à

partir de la tête) une valeur v dans la liste.

� Accès par position : il s'agit de rechercher (séquentiellement à

partir de la tête) le maillon (son adresse) qui se trouve à une

position donnée. La position est le numéro d'ordre du maillon

dans la liste (entier).

ALGORITHMES SUR LES LLCS

12

� Mises à jour :

� Construction d'une liste à partir de n valeurs données.

� Insertion d'une valeur (v) à une position donnée (i) : allouer un

nouveau maillon contenant v et l'insérer dans la liste de telle sorte

qu'il se retrouve à la i ème position.

� Insertion d'une valeur (v) dans une liste ordonnée : allouer un

nouveau maillon contenant v et l'insérer dans la liste de telle sorte

que la liste reste ordonnée après l'insertion.


13

� Mises à jour :

� Suppression du maillon se trouvant à une position donnée :

rechercher par position le maillon et le libérer.

� Suppression d'une valeur v dans la liste : rechercher par

valeur et supprimer le maillon trouvé en mettant à jour le

précédent (s'il existe). Si la liste contient plusieurs occurrences de

la même valeur, on pourra les supprimer en faisant un seul

parcours de la liste.

� Destruction de tous les maillons d'une liste.


14

� Tri sur les LLC : Les mêmes algorithmes de tri utilisable pour

les tableaux, en prenant en compte que l'accès par position coûte

beaucoup plus cher que dans un tableau.

� Algorithmes sur plusieurs LLC :

� Fusion (ou Interclassement) de deux listes ordonnées : à

partir de 2 listes ordonnées, construire une liste ordonnée

contenant tous leurs éléments (sans allouer de nouveaux

maillons).

� Eclatement d'une liste en 2 listes distinctes : à partir d'une

liste L et d'un critère (un prédicat) donné, on construit deux

listes, l'une contenant toutes les valeurs de L vérifiant le critère,

l'autre, celles qui ne le vérifient pas.


15

� Exercice 1: Soient L une liste d’entier non ordonnée.

Développer les modules suivants:

a. Imprimer la liste

b. Calculer la longueur de la liste.

c. Rechercher le maillon contenant la valeur « v » dans

la liste

d. Rechercher le maillon qui se trouve à la position K

e. Insérer une valeur « v » dans la liste

f. Insérer une valeur « v » à la position k

g. Construire la liste à partir de n données lues.


16

� Exercice 1 (suite): Soient L une liste d’entier non

ordonnée. Développer les modules suivants:

h) Supprimer une valeur « v » dans la liste.

i) Supprimer tous les maillons contenant la valeur

« v ».

j) Supprimer le maillon de position « pos ».

k) Détruire la liste


17

� Soient la liste suivante:

� La liste imprimée est 2, 10, 5, -1 et 6


IMPRESSION

2 10 5 -1 6

L

Procédure ImprimerLLC (L:*maillon)Début P �L;Tant que (P≠nil) faire // la liste n’est pas videDTQ

écrire (valeur (P))P ←suivant (P)

FTQFin

18


� La longueur de cette liste = 5


LONGUEUR

2 10 5 -1 6

L

Fonction LongLLC (L:*maillon): entierDébut P �L; Cpt �0;Tant que (P≠nil) faire // la liste n’est pas videDTQ

Cpt ++P ←suivant (P)

FTQRetourner (Cpt)Fin

19

� Rechercher une valeur « v=5 » dans la liste suivante:

� Si v= 1 alors

la fonction retourne nil.


RECHERCHE

2 10 5 -1 6

L

Fonction RechLLC (L:*maillon, v:entier): *maillonDébut P ←LTant que (P≠nil) faire // la liste n’est pas videDTQ

Si valeur (P) = v alors retourner (P)

Sinon P ←suivant (P)

FTQRetourner (nil)Fin

P

20

� Rechercher le maillon qui se trouve à la position k = 4

� Si k= 6, le maillon n’existe même pas (P = nil)


RECHERCHE

2 10 5 -1 6L

Fonction RechLLC_pos(L: *maillon, K: entier positif): *maillonDebutP ←L; i ←1Tant que (i<K) et (P≠nil) faire //accéder au K ème maillonDTQ

i++; P ←suivant (P);FTQRetourner (P);Fin

P

21

� Pour ajouter un élément dans la liste, il y a plusieurs

situations :

1. Insertion au début de la liste

2. Insertion à la fin de la liste

3. Insertion à une position donnée


INSERTION

22

� Cas 1: Insertion au début


INSERTION

-1 5 10 26

L

Paff_suiv (P, L)

Procédure InsererLLC_Deb(L:*maillon, v:entier)Début Allouer (P)aff_val(P, v) aff_suiv(P, L)L←P //mettre à jour la tête de la listeFin

23

� Cas 2: Insertion à la fin.


INSERTION

2 10 5 -1 6

L Q P

aff_suiv (Q, P)

Procédure InsererLLC_Fin (L:*maillon, v:entier)Début Allouer (P); aff_val(P, v); aff_suiv(P, nil)Si (L=nil) alors //la liste est vide

L ←P // mettre à jour l’entêteSinon

DsinonQ ←LTant que (suivant (Q)≠nil) faire // accéder au dernier maillon

Q ←suivant (Q)aff_suiv (Q, P)Fsinon

Fin

24

� Cas 3: Insertion à une position donné « k ».

� Si k = 1 alors insérer le maillon au début

� Sinon, accéder d’abord au maillon de position « k -1 »,

ensuite refaire le chaînage comme suit;


INSERTION

2 10 5 -1

6

L Q

P

(1) aff_suiv (P, suivant (Q))

k

(2) aff_suiv (Q, P)

25

ALGORITHMES SUR LES LLCSINSERTION

2 10 5 -1

6

L Q

P (1) aff_suiv (P, suivant (Q))

Procédure InsererLLC_pos (L:*maillon, k: entier positif, v:entier, var possible: booléen)Début possible �fauxSi (k>0) alors

Si (k=1) alors InsererLLC_Deb(L, v)possible � vrai

Sinon Q ←RechLLC_pos (L, k-1) ;

Si ((Q ≠ nil) et et (suivant (Q) ≠ nil)) // la position k existeAllouer (P); aff_val(P, v) ;aff_suiv (P, suivant (Q)) ; aff_suiv (Q, P)possible � vrai

Fin

k

(2) aff_suiv (Q, P)

26

� Pour créer une liste:

1. Allouer un nouveau maillon

2. Initialiser le maillon avec la valeur lue

3. Insérer dans la liste. On distingue deux cas:

a. Insertion à la fin

b. Insertion au début et la liste crée est inversée


CRÉATION

val suiv

??? ???

val suiv

2 NIL

27

� Cas 1: Insertion à la fin. Soient N= 5 et les valeurs suivantes: 2, 10, 5, -1, 6


CRÉATION

2 10 5 -1

6

LQ

P

aff_suiv (Q, P)

Procédure CreerLLC (L:*maillon)Début Pour i←1 à N faire DP

lire (x) Allouer (P)aff_val(P, x)

aff_suiv(P, nil)Si (L=nil) alors //la liste est vide


aff_suiv(Q, P)Q←P //sauvegarder l’@ du dernier maillon

FPFin

Procédure CreerLLC (L:*maillon)Début Pour i←1 à N faire DP

lire (v) InsererLLC_Fin(L, v)

FPFin

28

� Soient N= 5 et les valeurs suivantes: 2, 10, 5, -1, 6

� Cas 2: Insertion au début


CRÉATION

-1 5 10 2

6

L

Paff_suiv (P, L)

Procédure CreerLLC_inverse (L:*maillon)DébutPour i←1 à N faire DP

lire (x) Allouer (P)aff_val(P, x)

aff_suiv(P, nil)aff_suiv(P, L)L←P //mettre à jour la tête de la liste

FPFin

Procédure CreerLLC_inversé (L:*maillon)DébutPour i←1 à N faire

lire (v)InsérerLLC_Deb( L, v)

Fin

29

� Pour supprimer un maillon contenant la valeur v, il faut

d’abord rechercher ce maillon. Une fois trouvé (soit P ce

maillon), on va refaire le chaînage (son précédent avec

son suivant), ensuite, libérer le maillon P.


SUPPRESSION

30

� Exemple 1: Suppression v = 5

� Exemple 2 : Suppression v = 2


SUPPRESSION

2 10 5 -1 6

L

2 10 5 -1 6

PL

2 10 5 -1

L Q P

6

Q

31


SUPPRESSION

Procédure SupprimerLLC (L:*maillon, v:entier)Début P←L; Q�nil

TQ ((P ≠ nil) et (valeur (P) ≠ v) ) Q←P; P ←suivant (P)

FTQSi (P ≠ nil) alors

Si Q = nil alorsL ← suivant (P);

Sinon aff_suiv(Q,suivant (P));

libérer (P)Fin

/* rechercher le premier maillon contenant v*/

/* Suppression du premier maillon */

32

� Suppression de tous les maillons contenant la valeur v


SUPPRESSION

Procédure SupprimerLLC_tous (L:*maillon, v:entier)Début P←L; Q�nilTQ (P ≠≠≠≠ nil)

TQ ((P ≠ nil) et (valeur (P) ≠ v) ) Q←P; P ←suivant (P)

FTQSi (P ≠ nil) alors

Si Q = nil alorsL ← suivant (P); S��L;

Sinon aff_suiv(Q,suivant (P)); S��suivant (P);

libérer (P)P ��S;

Fin

/* rechercher le premier maillon contenant v*/

/* Suppression du premier maillon */

33

� Suppression à une position donnée « k ».

� Deux situations se présentent:

� k = 1, supprimer le premier maillon

� k ≠ 1, accéder d’abord au maillon de position « k-1»,

sauvegarder l’adresse du maillon « k+1 », ensuite

refaire le chaînage comme suit;


SUPPRESSION

2 10 5 -1

L Q

k

P

34

� Suppression à une position donné « k ».


SUPPRESSION

Procédure Supprimer_pos (L:*maillon, k:entier positif, Var possible : booléen) Début Possible �fauxSi (k>0) alors

Si (k = 1) alors // supprimer le premier maillonP←L; L ← suivant (L); libérer (P); Possible �vrai

Sinon Q←Rech_pos(L, k-1)Si ((Q ≠ nil) et (suivant (Q) ≠ nil)) // la position k existe

P� suivant (Q); aff_suiv(Q,suivant (P)); libérer (P); Possible �vrai

Fin

35



DESTRUCTION

2 10 5 -1 6

L

Procédure DetruireLLC (L:*maillon)Début Tant que (L≠nil) faire // la liste n’est pas videDTQ

P←LL ←suivant (L)libérer (P)

FTQFin

2 10 5 -1 6

LP

36

� Liste circulaire est une LLC où le dernier maillon

pointe le premier, formant ainsi un cercle.

� La tête de la liste est l'adresse de n'importe quel maillon.

� Le même modèle des LLC est utilisé pour écrire des

algorithmes sur ce type de listes: MLLCcir = MLLC

LISTES PARTICULIÈRES

LISTE CIRCULAIRE

…….V1 @1 V2 @2 V3 @3 Vn @n

Tête

37

� Impression d’une LLC circulaire


LISTE CIRCULAIRE (QUELQUES ALGORITHMES)

2 10 5 -1L

Procédure ImprimerLLCcir (L:*maillon)Début Si L ≠ nil alors

P←LRépéter

Écrire (valeur (P))P ←suivant(P)

Jusqu’à P=LFin

P

38

� Recherche le premier maillon contenant la valeur v



2 10 5 -1L

Fonction RechLLC_cir (L:*maillon, v:entier): *maillonDébut Si L ≠ nil alors

P←LRépéter

Si (valeur (P) = v) alors retourner (P)

P ←suivant(P)Jusqu’à P=L

Retourner (nil)Fin

P

39

� Insertion dans une LLC circulaire



2 10 5 -1

6

L

Procédure InsererLLCcir (L:*maillon, v:entier)Début Allouer (P)aff_val(P, v)

Si (L=nil) alors //la liste est videaff_suiv(P, P)L ←P // mettre à jour l’entête

Sinon aff_suiv(P , suivant (L))

aff_suiv (L, P)

Fin

P

Q

40

� Construction d’une LLC circulaire

� Construire une LLC unidirectionnel

� À la fin, chaîner le dernier maillon avec le premier



2 10 5 -1 6L

Procédure CreerLLCcir (L:*maillon, N:entier)Début Pour i←1 à N faire

lire (x) Allouer (P); aff_val(P, x)Si (L=nil) alors L ←P // mettre à jour l’entêteSinon aff_suiv(Q, P)Q←P //sauvegarder l’@ du dernier maillon

aff_suiv (P, L);Fin

Q P

41

� Construction d’une LLC circulaire



2 10 5 -1 6L

2 éme Méthode Procédure CreerLLCcir (L:*maillon, N:entier)Début Pour i←1 à N faire

lire (x); Allouer (P); aff_val(P, x) Si (L=nil) alors //la liste est vide


aff_suiv(Q, P)aff_suiv(P, L)// lier le dernier maillon au premierQ←P //sauvegarder l’@ du dernier maillon

Fin

Q P

42

� Suppression du maillon contenant la valeur v

� Rechercher le maillon contenant la valeur v

� S’il existe un tel maillon, on distingue deux cas:

1. La valeur se trouve dans le maillon « L »,

a. Si la liste contient qu’un seul maillon, alors la liste devient

vide

b. Sinon, mettre à jour le pointeur L et refaire le chaînage.

2. La valeur se trouve dans un autre maillon (≠ L), refaire le

chaînage



2 10 5 -1L

43


LISTES PARTICULIÈRES LISTE CIRCULAIRE

(QUELQUES ALGORITHMES)

Procédure SupprimerLLCcir (L:*maillon, v:entier)Début Si (L ≠ nil) alors // la liste n’est pas vide

P←Lrépéter

Q←PP ←suivant (P)

jusqu’à (P = L) ou (valeur (P) =v )Si valeur (P) =v alors // il existe un maillon contenant la valeur v

Si P = L alors //la valeur se trouve dans le maillon LSi P = Q alors // la liste contient un seul maillon

L ← nilSinon

L ← suivant (P); aff_suiv(Q,suivant (P))Sinon

aff_suiv(Q,suivant (P))libérer (P)

Fin

//rechercher le mailloncontenant la valeur v

44

� Destruction d’une LLC circulaire



2 10 5 -1L

Procédure DetruireLLC_cir (L:*maillon)Début Si L≠nil alors

P ←suivant (L) TQ (P≠L) faire

aff_suiv(L, suivant (P))libérer (P)P ←suivant (L)

FTQLibérer (P); L ←nil;

Fin

45

� Liste bidirectionnelle ou Liste Doublement

Chaînées est une liste que l'on peut parcourir dans les

deux sens : de gauche à droite (pour aller au maillon

suivant) et de droite à gauche (pour aller au maillon

précédent).

� Elle est définit par sa tête, aussi que par sa queue.


LISTE BIDIRECTIONNELLE

Tête

Nil

V1 V2 V3 V4 V5

Nil

Queue val suiv

prec

� Chaque maillon d’une liste bidirectionnelle comporte trois champs:

� Un champ contenant la donnée.

� Un pointeur vers l'élément suivant de la liste.

� Un pointeur vers l'élément précédent de la liste.



val suiv

type MaillonBD = Structure

val : typeqq

suiv: * MaillonBD

prec:*MaillonBD

fin

prec

46

type ListeBD= Structure

Tête: * MaillonBD

Queue:*MaillonBD

fin

Var L: ListeBD

� Le modèle des LLC bidirectionnelles est donc étendu par les

opérations suivantes :

MLLCbd = MLLC + { Init, Aff_prec, Précédent }



47

Fonction Rôle

Init (L) Initialiser la tête et la queue à Nil

Précédent(P) Accéder au champ « prec » du maillon d'adresse P.

Aff_prec(P, Q)Modifier le champ « prec » du maillon d'adresse P en lui affectant

le pointeur Q.

val suivprec

48

� Impression d’une LLC Bidirectionnelle


LISTE BIDIRECTIONNELLE (QUELQUES ALGORITHMES)

Tete

2 5 -1 6

Queue

Procédure ImprimerLLCbd (Var L: ListeBD)Début T�L.TeteTant que (T≠nil) faire // la liste n’est pas vide

écrire (valeur (T))T ←suivant (T)

Fin La liste imprimée est 2, 5, -1, 6

Procédure ImprimerLLCbd_inverse(Var L: ListeBDDébutQ � L.QueueTant que (Q≠nil) faire // la liste n’est pas vide

écrire (valeur (Q))Q ←precedent (Q)

Fin La liste imprimée est 6, -1, 5, 2

49

� Recherche d’une valeur dans une LLC Bidirectionnelle



Fonction RechLLCbd(L: ListeBD, v:entier): *MaillonBDDébut P ←L.TeteTant que (P≠nil) faire // la liste n’est pas vide

Si valeur (P) = v alors retourner (P)Sinon P ←←←←suivant (P)

Retourner (nil)Fin

Tete

2 5 -1 6

Queue

Fonction RechLLCbd (L: ListeBD, v:entier): *MaillonBDDébut P ←L.QueueTant que (P≠nil) faire // la liste n’est pas vide

Si valeur (P) = v alors retourner (P)Sinon P ←←←←précédent (P)

Retourner (nil)Fin

50

� Recherche du maillon qui se trouve à une position donnée



K

Tete

2 5 -1 6

QueueP

RechLLCbd_pos(L: ListeBD, K: entier positif): *maillonBDDebutP ←L.Tete; i ←1Tant que (i<K) et (P≠nil) faire //accéder au K ème maillonDTQ

i++; P ←suivant (P);FTQRetourner (P);Fin

51

� Insertion au début de la liste



Aff_suiv (P, Tete)Tete

Queue

-1 5 26

P

Aff_prec (Tete, P)

Procédure InsererLLCbd_Deb (Var L: ListeBD, v:entier)Début Allouer (P); aff_val(P, v); Si L.Tete = nil alors // si la liste est vide

aff_suiv(P, nil); aff_prec(P, nil)L.Tete ←P; L.Queue ←P

Sinon aff_prec (P, nil);aff_suiv (P, L.Tete) ; aff_prec (L.Tete, P)L.Tete←←←←P //mettre à jour la tête

Fin

52

� Insertion à la fin de la liste.



Procédure InsererLLCbd_Fin (Var L: ListeBD, v:entier)Début Allouer (P); aff_val(P, v); Si L.Queue = nil //la liste est vide

aff_suiv(P, nil); aff_prec(P, nil)L.Tete ←P; L.Queue ←P

Sinon aff_suiv(P, nil)aff_suiv (L.Queue, P); aff_prec (P, L.Queue)L.Queue←←←←P //mettre à jour la queue

Fin

Aff_suiv (Queue, P)Tete

Queue

2 5 -1 6

P

Aff_prec (P, Queue)

53

� Insertion à une position donnée



P

K

Tete

2 5 -1 6

QueueS6

(1)(2)

(3)

(4)

Procédure InsererLLCbd_pos (Var L: ListeBD, v:entier, K:entier positif)Si K>0 alors

Si K = 1 alors InsererLLCbd_Deb(L, v)Sinon

S�RechLLCbd_pos(L, K):;Si S ≠ NilAllouer (P); aff_val(P, v); aff_suiv (Precedent (S), P) ; aff_prec (P, Precedent (S)); aff_suiv (P, S) ;aff_prec (S, P) ;

54

� Construction d’une LLC Bidirectionnelle

� Soient N= 4 et les valeurs suivantes: 2, 5, -1, 6



Aff_suiv (Q, P)Tete

Queue

2 5 -1 6

P

Aff_prec (P, Q)

Procédure CreerLLCbd (Var L: ListeBD)Début Init (L)Pour i←1 à N faire

lire (x); InsererLLCbd_Fin (L, x);

Fin

55

� Construction d’une LLC Bidirectionnelle

� Soient N= 4 et les valeurs suivantes: 2, 5, -1, 6



Aff_suiv (P, T)

Tete Queue

-1 5 26

P

Aff_prec (T, P)

Procédure CreerLLCbd_inverse(Var L: ListeBD)Début Init (L)Pour i←1 à N faire

lire (x); InsererLLCbd_Deb (L, x);

Fin

56




2 5 -1 6

Procédure SupprimerLLCbd (Var L: ListeBD v:entier)Si (L.Tete ≠ nil) alors // la liste n’est pas vide

P← RechLLCbd (L, v)Si P ≠ nil alors // il existe un maillon contenant la valeur v

Si P = L.Tete = L.Queue alors // la liste contient un seul maillonInit (L)// T ←←←←nil; Q ←←←←nil i.e. la liste devient vide

Sinon Si P = L.Tete alors //suppression au débutL.Tete ← suivant (P); aff_prec(L.Tete, nil);

Sinon Si P = L.Queue alors //suppression à la finL.Queue← précédent (P); aff_suiv(L.Queue, nil)Sinon

aff_suiv(precedent (P), suivant(P));aff_prec(suivant(P), precedent (P));

libérer (P)

QueueTete P

57

� Destruction d’une LLC Bidirectionnelle



Tete

2 5 -1 6

Queue

Procédure DetruireLLCbd (Var L: ListeBD)Début T�L.TeteTant que (T≠nil) faire

P←TT ←←←←suivant (T)libérer (P)

Init (L);Fin

Procédure DetruireLLCbd (Var L: ListeBD)Début Q�L.QueueTant que (Q≠nil) faire

P←QQ ←←←←precedent (Q)libérer (P)

Init (L);Fin

58

� Liste bidirectionnelle circulaire est une LLC à double

sens et dont le dernier maillon pointe sur le premier

maillon et le premier maillon pointe sur le dernier

maillon.

� Le même modèle des LLCs bidirectionnel est utilisé pour

écrire des algorithmes sur ce type de liste:

MLLCbdcir = MLLCbd


LISTE BIDIRECTIONNELLE CIRCULAIRE

Tête

V1 V2 V3 V4 V5

59

� On peut représenter une LLC par un tableau où chaque

élément contient au moins 3 champs : l'information,

l’indice du suivant et l’indicateur vide.

� Exemple d’une LLC unidirectionnel:

REPRÉSENTATION CONTIGÜE

DÉFINITION

Tête

12 8 23 45

Nil

Vide Val Suiv

F 12 4

F 23 7

V

F 8 2

V

V

F 45 -1

Tête = 0

60

� Initialement, le champ Vide de tous les éléments sont à

vrai pour indiquer que les cases sont disponibles.

� Une LLC est définie par l'indice de son premier élément

dans le tableau T

Vide Val Suiv

F 12 4

F 23 7

V

F 8 2

V

V

F 45 -1

Définition de la structure :

type element = Structurevide : Booléenval : typeqqsuiv : Entier

fin

var Liste : tableau [Max] de element

Tête = 0

REPRÉSENTATION CONTIGÜE

DÉFINITION

61

� Le modèle de la LLC est défini comme suit:

Modules Rôle

Allouer(L, N)C’est une fonction qui retourne l’indice de la case libre dans letableau L du taille max sinon la valeur -1 s'il n’y a pas deplace.

Libérer(L,P)C’est une procédure qui positionne le champs « vide » de lacase L[P] à vrai

Valeur(L, P)C’est une fonction qui retourner le contenu du champs « val »de la case L[P].

Suivant(L, P)C’est une fonction qui retourne le contenu du champs « suiv »de la case L[P]

aff_suiv(L, P, Q)C’est une procédure qui affecte l’entier Q dans le champs «suiv » de la case L[P]

Aff_Val(L, P,v)C’est une procédure qui affecte la valeur v dans le champs «

val » de la case L[P]

REPRÉSENTATION CONTIGÜEMODÈLE

62

Modules Code Complexité

Allouer(L, max) Pour i←0 à max-1 faireSi L[i].Vide alors

L[i] ←fauxRetourner(i)

Retourner (-1)

O(max)

Libérer(L,P) L[P].Vide ← vrai O(1)

Valeur(L, P) Retourner (L [P].val) O(1)

Suivant(L, P) Retourner (L [P].suiv) O(1)

aff_suiv(L, P, Q) L[P] .suiv← Q O(1)

Aff_Val(L, P, v) L[P] .val← v O(1)

REPRÉSENTATION CONTIGÜEMODÈLE

Faut-il utiliser

un tableau ou

une LLC?

CONCLUSION

63

64

Tableau non ordonné LLC unidirectionnelle non ordonné

Accès à un élément

Direct (O(1)) Séquentielle (O(n))tq n est la longueur de la liste

Ajout Recherche séquentielle d’une case

vide O(n)

Chaînage:

Au début O(1)A la fin O(n)

Suppression Décalage O(n)

Chaînage:

Au début O(1)À la fin O(n)

Définition de la relation suivant:

Implicitedéfinie par la contiguïté

des composantes du tableau

ExpliciteOn peut la modifier , i.e. les

maillons des LLC peuvent être réarrangés sans avoir à déplacer les informations qu’ils portent).De plus, un même maillon peut faire partie de plusieurs listes.

CONCLUSION

65

Tableau non ordonné LLC unidirectionnelle non ordonné

Sur-

encombrement

Non:

La relation suivant étant

implicite, il n’y a pas besoin

d’espace supplémentaire pour

son codage.

Oui:

l’encombrement de chaque

maillon est augmenté de la

taille du pointeur suivant

Encombrement

total selon le

besoin

Non:

avec l’allocation statique,

l’encombrement d’un tableau

est constant (fixé d’avance).

Oui:

avec l’allocation dynamique

des maillons, le nombre de

maillons d’une LLC

correspond au nombre

d’éléments effectivement

présents

CONCLUSION

PARTIE II:

FILES D’ATTENTE

PLAN DE LA PARTIE II

� Définition

� Utilisation

� Modèle

� Implémentation

� Représentation statique

� Représentation dynamique

� File d’attente avec priorité 67

68

� Une file (en anglais queue) est une structure de données

basée sur le principe « premier arrivé, premier sorti » (en

anglais FIFO: First In First Out),

� Le fonctionnement ressemble à une file d'attente : les

premières personnes à arriver sont les premières

personnes à sortir de la file.

DÉFINITION

69

� Une file d'attente peut être définie comme une collection

d'éléments dans laquelle tout nouvel élément est inséré

(ajouté) à la fin (queue) et tout élément ne peut être

supprimé (retiré) que du début (Tête).

DÉFINITION

Retrait (Défilement )Ajout (enfilement)

têtequeue

70

� Les files d’attente sont utilisées, en programmation

comme des buffers (mémoire tampon = espace de

mémorisation temporaire) , pour gérer des objets qui

sont en attente d’un traitement ultérieur, tel que la

gestion des documents à imprimer, des programmes à

exécuter, des messages reçus,...etc.

� Elles sont utilisées également dans le parcours des

arbres.

UTILISATION

71

� Les opérations habituelles sur les files sont :

� Initialisation de la file

� Vérification du contenu de la file (vide ou pleine)

� Enfilement : ajout d’un élément à la queue de la file

� Défilement : retrait d’un élément de la tête de la file

MODÈLE

Opération Rôle

Initfile(F) créer une file vide

Enfiler(F,Val) ajouter Val à la queue de file

Défiler(F,Val) retirer dans Val l'élément en tête de file

Filevide(F) tester si la file est vide

Filepleine(F) tester si la file est pleine

72

� Les files d’attente peuvent être présentées en deux

manières:

� statique en utilisant les tableaux,

� dynamique en utilisant les listes linéaires

chaînées.

� L’implémentation statique peut être réalisée par

� décalage en utilisant un tableau avec une tête fixe,

toujours à 0, et une queue variable.

� tableau circulaire où la tête et la queue sont toutes

les deux variables.

IMPLÉMENTATION

73

� A chaque défilement, on fait un décalage.

� La tête n'est plus une caractéristique puisqu'elle est toujours

égale à 0.

IMPLÉMENTATION STATIQUE PAR DÉCALAGE

V0 V1 V2 V3 V4 V5

Tête = 0 Queue = 5

Défiler

Décalage

V1 V2 V3 V4 V5

Queue = 4

74



TYPE File_Attente = STRUCTURE

Elements : TABLEAU[Max] de Typeqq

Queue : ENTIER

FIN

VAR F : File_Attente

V1 V2 V3 V4 V5 V6

Queue

File_Attente

Eléments

75


Modèle Implémentation

Initfile(F) F.Queue ←-1

Filevide(F) Retourner (F.Queue = -1)

Filepleine(F) Retourner (F.Queue = Max-1)

Enfiler(F,X) SI (NON Filepleine(F))

F.Queue ← F.Queue + 1

F.Elements[F.Queue] ←X

Defiler(F,X) SI (NON Filevide(F))

X ← F.Elements[0]

POUR I ← 0 à F.Queue - 1

F.Elements[I] ← F.Elements[I+1]

F.Queue ← F.Queue – 1

76

� Les incrémentations se font modulo N afin de réutiliser des

cases libérées:

Tete ←←←← (Tete+1) mod Max & Queue ←←←← (queue+1) mod Max

� Par convention,

� L'élément d'indice tête sera sacrifié (case vide).

� Le premier élément se trouve alors à l'indice (tête+1 mod

Max)

IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE

V0 V1 V2 V3 V4 V5

Tête = 8Queue = 5

77


V1 V2 V3 V4 V5

Tête = 0 Queue = 5

V2 V3 V4 V5

Tête = 1 Queue = 5

Tête = Queue = 5

� Défiler (F, V)

� Pour i←←←←1 à 4 faire Défiler (F, V)

File Vide ssi Tête = Queue

78


V3 V4 V5 V6 V7 V8

Tête = 2 Queue = 8

V9 V3 V4 V5 V6 V7 V8

Tête = 2Queue = 0

� Enfiler (F, V9)

V9 V10 V3 V4 V5 V6 V7 V8

Tête = 2Queue = 1

� Enfiler (F, V10)File Pleine ssi :tete = (queue+1) mod Max

Queue ←←←← (queue+1) mod Max

79





Tête, Queue : ENTIER

FIN

VAR F : File_Attente

File_Attente

Eléments

V2 V3 V4 V5

Tête = 1 Queue = 5

80



Initfile(F) F.Tête ←Max; F.Queue ←Max

Filevide(F) Retourner (F.Tête = F.Queue)

Filepleine(F) Retourner (F.Tête = ( (F.Queue +1) Mod Max ))

Enfiler(F,X) SI (NON Filepleine( F))

F.Queue ← (F.Queue + 1) Mod Max

F.elements[F.Queue] ← X


F.Tete ← (F.Tete + 1)Mod Max

X ← F.elements[F.Tete]

81

� La représentation dynamique utilise une liste linéaire chaînée

(LLC). L’enfilement se fait à la queue de la liste et de

défilement se fait de la tête. La file d’attente, dans ce cas, peut

devenir vide, mais ne sera jamais pleine.

� Les opérations de base sont :

� Initialisation de la file

� Enfilement : insertion d’un élément à la queue de la LLC

� Défilement : suppression d’un élément de la tête de la LLC

� Vérification si la LLC n’est pas vide

IMPLÉMENTATION DYNAMIQUE

V0 V1 V2 V3 V4

Tête Queue

EnfilementDéfilement

82


V0 V1 V2 V3 V4

Tête Queue


TYPE Maillon = STRUCTURE

val : typeqq

suiv: * Maillon

FIN


Tête, Queue : *Maillon

FIN

VAR F: File_Attente

File_Attente

83



Initfile(F) F.Tete ← NIL; F.Queue← NIL

Filevide(F) Retourner (F.Tete = NIL )

Enfiler(F,X) Allouer (P), Aff_Val(P, X), aff_suiv(P, NIL)

SI (NON Filevide(F))

aff_suiv(F.Queue, P)

SINON

F.Tete ← P

F.Queue ← P


P ← F.Tete

X ← Valeur(F.Tete)

F.Tete ← Suivant(F.Tete)

Liberer(P)

84

� Une file d’attente avec priorité est une collection

d’éléments dans laquelle l’insertion ne se fait pas toujours

à la queue.

� Tout nouvel élément est inséré dans la file, selon sa

priorité.

� Le retrait se fait toujours du début.

� Dans une file avec priorité, un élément prioritaire

prendra la tête de la file même s’il arrive le dernier.

� Un élément est toujours accompagné d’une information

indiquant sa priorité dans la file.

FILE D’ATTENTE AVEC PRIORITÉ

85

�Exercice 6:

� Le processeur possède un buffer permettant de gérer ses programmes

à exécuter. Ce buffer est une file d'attente avec priorité où les

éléments (programmes) sont caractérisés par une priorité

d’exécution: un programme de priorité supérieure est servi même s’il

n’est pas arrivé le premier.

� Sachant qu’un programme est défini par sa priorité et son mot d’état

programme (Program Status Word ou PSW) qui regroupe l’adresse de

la prochaine instruction (CO) et les bits du registre de flag. Définir

les structures de données nécessaires ainsi que le modèle de

file, pour chaque type de présentation (statique par décalage,

statique par tableau circulaire et dynamique).


86




TYPE prog = STRUCTURE

prio : ENTIER

PSW : typeqcq

FIN


Elements : TABLEAU[Max] de prog

Queue : ENTIER

FIN

(3,PSW)

(2,PSW)

(1,PSW)

(1,PSW)

(0,PSW)

Queue

87




Initfile(F) F.Queue ←-1

Filevide(F) Retourner (F.Queue = -1)

Filepleine(F) Retourner (F.Queue = Max-1)


X ← F.Elements[0]

POUR I ← 0 à F.Queue - 1

F.Elements[I] ← F.Elements[I+1]

F.Queue ← F.Queue – 1

88



(3,PSW)

(2,PSW)

(1,PSW)

(1,PSW)

(0,PSW)

Queue

� Enfiler (F, (2, PSW))

(3,PSW)

(2,PSW)

(2,PSW)

(1,PSW)

(1,PSW)

(0,PSW)

Queue

89



� Enfilement:

� 1ère méthode: rechercher la bonne position (soit i), décaler les

éléments (i à Queue) vers la droite, insérer le nouvel élément

et enfin incrémenter la queue.

� 2ème méthode: faire un décalage à droite en commençant par la

queue jusqu’à trouver la bonne position du nouvel élément,

insérer le nouvel élément et enfin incrémenter la queue.

� 3ème méthode: incrémenter la queue, insérer le nouvel élément

à la queue ensuite essayer de trier le tableau en faisant des

permutations (principe de tri par insertion),

90



1ère méthode: Enfiler(F,X)

SI (NON Filepleine(F))I ← 0 //rechercher la bonne position où enfiler X

TQ (I <F.Queue) & (F.Elements[I].priorité ≥ X.priorité ) faireI←I+1

//décaler les programmes moins prioritaires

J � F.QueueTQ (J≥I) faire

F.Elements[J+1] ← F.Elements[J] J�J-1

//insérer le programme X

F.Elements[I] ← X//mettre à jour la queue


91



2ère méthode: Enfiler(F,X)

SI (NON Filepleine(F))I ← F.Queue//décaler les programmes moins prioritaires jusqu’à

trouver la bonne position où enfiler X

TQ (I ≥0) & (F.Elements[I].priorité < X.priorité ) faireF.Elements[I+1] ← F.Elements[I] I←I-1

//insérer le programme X

F.Elements[I] ← X//mettre à jour la queue


92



3ème méthode: Enfiler(F,X)

SI (NON Filepleine(F))//mettre à jour la queue

F.Queue ← F.Queue + 1//insérer le programme X

F.Elements[F.Queue] ← X//trier le tableau d’éléments

I ← F.Queue -1TQ (I ≥0) & (F.Elements[I].priorité > F.Elements[I+1].priorité ) faire

Tmp �F.Elements[I] F.Elements[I+1] ← F.Elements[I] F.Elements[I] ← Tmp I←I-1

93





prio : ENTIER

PSW : typeqcq

FIN


Elements : TABLEAU[Max] de prog

Queue, Tete : ENTIER

FIN

(3,PSW)

(2,PSW)

(1,PSW)

(1,PSW)

(0,PSW)

TeteQueue

94




Initfile(F) F.Tête ←Max; F.Queue ←Max

Filevide(F) Retourner (F.Tête = F.Queue)

Filepleine(F) Retourner (F.Tête = ( (F.Queue +1) Mod Max ))

Defiler(F,X) SI ‘(NON Filevide(F))

F.Tete ← (F.Tete + 1)Mod Max

X← F.elements[F.Tete]

95



(3,PSW)

(2,PSW)

(1,PSW)

(1,PSW)

(0,PSW)

Queue


(3,PSW)

(2,PSW)

(2,PSW)

(1,PSW)

(1,PSW)

(0,PSW)

Queue

Tete

Tete

96



(1,PSW)

(0,PSW)

(3,PSW)

(2,PSW)

(1,PSW)

Queue


Tete

(1,PSW)

(1,PSW)

(0,PSW)

(3,PSW)

(2,PSW)

(2,PSW)

Queue Tete

97



� Enfilement:

� 1ère méthode: rechercher la bonne position (soit i), décaler les

éléments (i à Queue) vers la droite, insérer le nouvel élément

et enfin incrémenter la queue � décalage circulaire.

� 2ème méthode: faire un décalage à droite en commençant par la

queue jusqu’à trouver la bonne position du nouvel élément,

insérer le nouvel élément et enfin incrémenter la queue. �

décalage circulaire.

98



� Enfilement:

� 3ème méthode: insérer le nouvel élément à la queue ensuite

essayer de trier le tableau en faisant des permutations

(principe de tri par insertion)

(1,PSW)

(0,PSW)

(2,PSW)

(3,PSW)

(2,PSW)

(1,PSW)

Queue Tete

(1,PSW)

(1,PSW)

(0,PSW)

(3,PSW)

(2,PSW)

(2,PSW)

Queue Tete

99



3ème Méthode: Enfiler(F,X)

SI (NON Filepleine(F))//mettre à jour la queue

F.Queue ← (F.Queue + 1) mod Max//insérer le programme X

F.Elements[F.Queue] ← X//trier le tableau d’éléments

I ← F.QueueSi I=0 alors J��Max-1; Sinon J��I-1TQ (I ≠F.Tete) & (F.Elements[I].priorité > F.Elements[J].priorité ) faire

Tmp �F.Elements[I] F.Elements[I] ← F.Elements[J] F.Elements[J] ← TmpSi I=0 alors I��Max-1; Sinon I��I-1Si J=0 alors J��Max-1; Sinon J��J-1

100



� Enfilement:

� 3ème méthode: insérer le nouvel élément à la queue ensuite


(principe de tri par insertion)� Décrémentation des indices!!

� 4ème méthode: insérer le nouvel élément à la tête ensuite


(principe de tri par insertion)

101



(2,PSW)

(3,PSW)

(2,PSW)

(1,PSW)

(1,PSW)

(0,PSW)

Queue


(3,PSW)

(2,PSW)

(2,PSW)

(1,PSW)

(1,PSW)

(0,PSW)

Queue

Tete

Tete

102



(2,PSW)

(3,PSW)

(2,PSW)

(1,PSW)

(1,PSW)

(0,PSW)

Queue


(3,PSW)

(2,PSW)

(2,PSW)

(1,PSW)

(1,PSW)

(0,PSW)

Queue

Tete

Tete

103



(3,PSW)

(2,PSW)

(1,PSW)

(1,PSW)

(0,PSW)

(2,PSW)

Queue


(2,PSW)

(2,PSW)

(1,PSW)

(1,PSW)

(0,PSW)

(3,PSW)

Queue

Tete

Tete

104



(1,PSW)

(0,PSW)

(2,PSW)

(3,PSW)

(2,PSW)

(1,PSW)

Queue


Tete

(1,PSW)

(0,PSW)

(3,PSW)

(2,PSW)

(2,PSW)

(1,PSW)

Queue Tete

105



4ème Méthode: Enfiler (F, X)

SI (NON Filepleine(F))//insérer le programme X

F.Elements[F.Tete] ← X//trier le tableau d’éléments

I ← F..TeteJ��(I+1)mod Max;TQ (I ≠F.TQueue) & (F.Elements[I].priorité > F.Elements[J].priorité ) faire

Tmp �F.Elements[I] F.Elements[I] ← F.Elements[J] F.Elements[J] ← Tmp I��(I+1)mod Max;J��(J+1)mod Max;

//mettre à jour la Tête

Si F.Tete=0 alors F.Tete��Max-1; Sinon F.Tete��I-1

106



(3,PSW)

Tête Queue

(2,PSW) (1,PSW) (1,PSW) (0,PSW)



prio : ENTIER

PSW : typeqcq

FIN


val : prog

suiv: * Maillon

FIN


TêTe, Queue : *Maillon

FIN

107




Initfile(F) F.Tete ← NIL

F.Queue← NIL

Filevide(F) Retourner (F.Tete = NIL )


P ← F.Tete

X ← Valeur(F.Tete)

F.Tete ← Suivant(F.Tete)

Liberer(P)

108




(3,PSW)

Tête Queue

(2,PSW) (1,PSW) (1,PSW) (0,PSW)

(2,PSW)

(3,PSW)

Tête Queue

(2,PSW) (1,PSW) (1,PSW) (0,PSW)

109


IMPLÉMENTATION DYNAMIQUEEnfiler(F,X)

Allouer (P), Aff_Val(P, X), aff_suiv(P, NIL)

Si (Filevide(F)) F.Tete ← P; F.Queue ← P

Sinon

Si (X.prio >Valeur(F.Tete).prio) alors //insertion au début

aff_suiv(P, F.Tete); F.Tete←P

Sinon

S←L

TQ (suivant (S)≠Nil) et (valeur (suivant (S))≥X.prio) faire

S← suivant (S)

Si (suivant (S) = Nil) alors //insertion à la fin

aff_suiv (S, P); F.Queue ← P

Sinon //insertion au milieu

aff_suiv(P, suivant (S)), aff_suiv(S, P)

PARTIE III:

PILES

PLAN DE LA PARTIE III

� Définition

� Modèle

� Implémentation

� Représentation statique

� Représentation dynamique

� Utilisation

111

112

� Une pile (en anglais stack) est une structure de données

fondée sur le principe « dernier arrivé, premier sorti » (ou

LIFO: Last In, First Out)

� Les derniers éléments ajoutés à la pile seront les premiers à être

récupérés.

DÉFINITION

� Le fonctionnement ressemble à une piles

des livres: On ajoute des livres sur la pile,

et on les récupère dans l'ordre inverse, en

commençant par le dernier ajouté.

113

� Une pile peut être définie comme une collection

d'éléments dans laquelle tout nouvel élément est inséré à

la fin (empilement) et tout élément ne peut être

supprimé que de la fin (dépilement).

� Les insertions et les suppressions d’éléments se font à une seule

et même extrémité de la liste appelée le sommet de la pile.

DÉFINITION

12

7

18

3Sommet

DépilementEmpilement

114

� Les opérations habituelles sur les piles sont :

� Initialisation de la pile

� Vérification du contenu de la pile (vide ou pleine)

� Empilement : ajout d’un élément au sommet de la pile

� Dépilement : retrait d’un élément du sommet de la pile

MODÈLE

Opération Rôle

InitPile(P) créer une pile vide

Empiler(P,Val) ajouter Val en sommet de pile

Dépiler(P,Val) retirer dans Val l'élément en sommet de pile

Pilevide(P) tester si la pile est vide

Pilepleine(P) tester si la pile est pleine

115

� Les piles peuvent être présentées en deux manières:

� statique en utilisant les tableaux,

� dynamique en utilisant les listes linéaires

chaînées.

IMPLÉMENTATION

116

� L’implémentation statique des piles utilise les tableaux.

Dans ce cas, la capacité de la pile est limitée par la taille

du tableau (max). L’ajout à la pile se fait dans le sens

croissant des indices, tandis que le retrait se fait dans le

ses inverse.

IMPLÉMENTATION STATIQUE

Sommet =5 V5

V4

V3

V2

V1

V0

DépilementEmpilement

0

max-1

117



TYPE Pile= STRUCTURE


Sommet : ENTIER

FIN

VAR P : Pile

Pile

Eléments

Sommet =5 V5

V4

V3

V2

V1

V0 0

max-1

118

IMPLÉMENTATION STATIQUE

modèle Implémentation

Initpile(P) P.Sommet ← -1

Pilevide(P) Retourner ( P.Sommet = -1)

Pilepleine(P) Retourrner (P.Sommet = Max-1)

Empiler(P, X) SI NON Pilepleine(P)

P.Sommet ← P.Sommet + 1

P.Elements[P.Sommet] ← X

Sinon « Overflow »

Depiler(P, X) Si NON Pilevide(P)

X ← P.Elements [P.Sommet]

P.Sommet ← P.Sommet – 1

Sinon « Underflow »

119

� L’implémentation dynamique utilise les listes linéaires

chinées. Dans ce cas, la pile peut être vide, mais ne peut être

jamais pleine, sauf bien sur en cas d’insuffisance de l’espace

mémoire. L’empilement et le dépilement dans les piles

dynamique se font à la tête de la liste.

� Les opérations de base sont :

� Enfilement : insertion d’un élément à la tête de la LLC

� Défilement : suppression d’un élément de la tête de la LLC

� Vérification si la LLC n’est pas vide


V4 V3 V2 V1 V0

Sommet (Tête)Empilement

Dépilement

120


V4 V3 V2 V0 V1

Sommet



val : typeqq

suiv: * Maillon

FIN

VAR sommet: *Maillon

Pile

121



Initpile(Sommet) Sommet ← Nil

Pilevide(Sommet) Retourner (Sommet = Nil)

Empiler(Sommet, X) Allouer (Q)

Aff_Val(Q, X)

aff_suiv(Q, Sommet)

Sommet ← Q

Depiler(Sommet, X) Si NON Pilevide(Sommet)

X ← Valeur(Sommet)

Q ← Sommet

Sommet ←Suivant(Sommet)

Liberer(Q)

Fsi

122

� Analyse syntaxique : qui est une phase de la

compilation qui nécessite une pile.

� Par exemple, le problème de la reconnaissance des mots entreparenthèses:

� accepter les mots comme (), ()(()) ou ((()())()) ;

� rejeter les mots comme )(, ()(() ou ((()()))).

� Pour le résoudre, on stocke les parenthèses ouvrantes non encorerefermées dans une pile de caractères. Autrement dit, on lit caractèrepar caractère, s’il s’agit d’une parenthèse :

� ouvrante, elle est empilée ;

� fermante, la parenthèse ouvrante correspondante est dépilée.

� Le mot est accepté si la pile est vide lorsque le mot a été lu.

UTILISATION

123

� Calcul arithmétique : Une application courante des

piles se fait dans le calcul arithmétique: l'ordre dans la

pile permet d'éviter l'usage des parenthèses.

� Exercice 9 (Evaluation d’expression arithmétique postfixée):

� Une expression arithmétique est une combinaison des opérandes (les

nombres), des opérateurs [+, -, * ; /, %] et des parenthèses [(, )]. Elle

est habituellement écrite de manière infixée, c'est à dire que

l'opérateur est placé entre ses deux opérandes. On trouve aussi une

notation postfixée où l'opérateur est placé après ses opérandes.

L'intérêt de cette notation est qu'il n'y a plus besoin de connaître les

priorités des opérateurs, et donc plus besoin de parenthèses.

UTILISATION

124

EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)

� Il est demandé de réaliser une calculette qui prend en entrée une

LLC représentant une expression arithmétique en notation infixée, et

qui affiche le résultat de l'évaluation de cette expression, en utilisant

une pile statique.

1. Ecrire les expressions suivantes en postfixée:

5*(((9+8)*(4*6))+7), ~3+2-5*6/2+3, (1+3*4+2)*5

Notation Format Exemples

Infixée <expG> <op> <expD> a + b, a + b * c, (a+b) * c, -a + b

Postfixée <expG> <expD> <op> a b +, a bc* +, ab+ c *, a- b +

125

1. Ecrire les expressions suivantes en postfixée:

2. Une expression arithmétique peut être implémentée

sous forme d’une LLC où les maillons sont déclarés

comme suit:

Expressions en infixée Expressions en postfixée

5 *(((9+8)*(4*6))+7) 5 98*46**7+*

~3+2-5*6/2+3 3~2+56*2/-3+

(1+3*4+2)*5 134*+2+5*


1262. Donner la LLC qui présente cette expression

5 * (((9+8)*(4*6))+7) en format infixé et postfixé.

Type Terme = structure

Op : Chaines de caractères;

Prio : {0,1, 2, 3, 4};

Fin

Type maillon = structure

Val : Terme;

Suiv : * maillon ;

Fin

Prio Signification

0 Opérande

1 Opérateur binaire (+, -)

2 Opérateur binaire ( *, /, %)

3 Opérateur unaire ( - unaire)

4 Parenthèse ouvrante ou fermante


127

[‘5’, 0] [‘*’, 2] [‘(’, 4] [‘(’, 4] [‘(’, 4]

[‘9’, 0][‘+’, 2][‘8’, 0][‘)’, 4]

[‘(’, 4] [‘4’, 0] [‘*’, 2] [‘6’, 0]

[‘)’, 4][‘)’, 4][‘+’, 2][‘)’, 4]

[‘*’, 2]

Linfixe

� La LLC qui présente cette expression

5*(((9+8)*(4*6))+7).


[‘7’, 0]

128

[‘5’, 0] [‘9’, 0] [‘8’, 0] [‘*’, 2] [‘4’, 0]

[‘6’, 0][‘*’, 2][‘*’, 2][‘7’, 0]

[‘*’, 2]

[‘+’, 1]

Lpostfixe

� La LLC qui présente cette expression 598*46**7+*


129

3. Ecrire l’algorithme qui permet de transformer une

expression infixée en une expression postfixée.

� Exemples illustratif:


Expressions en infixée Expressions en postfixée

5 *(((9+8)*(4*6))+7) 5 98+46**7+*

~3+2-5*6/2+3 3~2+56*2/-3+

(1+3*4+2)*5 134*+2+5*

130

1. Inserer ([5, 0])

2. Empiler ([*, 2])

3. Empiler ([(, 4])

4. Empiler ([(, 4])

5. Empiler ([(, 4])

6. Inserer ([9, 0])

7. Empiler ([+, 1])

8. Inserer ([8, 0])

9. Depiler ([+, 1]); inserer ([+, 1]); Depiler ([(, 4])

10. Empiler ([*, 2])

11. Empiler ([(, 4])

[*, 2][(, 4]

2 - 5

[(, 4][(, 4]

7

[*, 2][(, 4][(, 4][(, 4][+, 1]

� Exemple 1: 5 * (((9+8)*(4*6))+7) � 598+

10 - 11

[*, 2][(, 4][(, 4][*, 2][(, 4]


131

12. Inserer ([4, 0])

13. Empiler ([*, 2])

14. Inserer ([6, 0])

15. Depiler ([*, 2]); inserer ([*, 2]); Depiler ([(, 4])

16. Depiler ([*, 2]); inserer ([*, 2]); Depiler ([(, 4])

17. Empiler ([+, 1]);

18. Inserer ([7, 0])

19. Depiler ([+, 1]); inserer ([+, 1]); Depiler ([(, 4])

20. Depiler ([*, 2]); inserer ([*, 2]);

13

[*, 2][(, 4][(, 4][*, 2][(, 4][*, 2]

[(, 4]

15 - 16

[*, 2]

[(, 4][*, 2][(, 4][*, 2]

� Exemple 1: 5 * (((9+8)*(4*6))+7) � 598+46**7+*

17 - 20

[*, 2][(, 4][+, 1]


132

1. Empiler ([~, 3])2. Inserer ([3, 0])3. Depiler ([~, 3]); inserer ([~, 3]); Empiler ([+, 1])4. Inserer ([2, 0])5. Depiler ([+, 1]); insérer ([+, 1]), Empiler ([-, 1])6. Inserer ([5, 0])7. Empiler ([*, 2]8. Inserer ([6, 0])9. Depiler ([*, 2]); inserer ([*, 2]); Empiler ([/, 2])10. Inserer ([2, 0])11. Depiler ([/, 2]); inserer ([/, 2]); Depiler ([-, 1]); inserer ([-, 1]);

Empiler ([+, 1])12. Inserer ([3, 0])13. Depiler ([+, 1]); inserer ([+, 1]);

[~, 3]

1

[-, 1]

5

[+, 1]

3

[-, 1]

7

[*, 2]

� Exemple 2: ~3+2-5*6/2+3�3~2+56*2/-3+

[-, 1]

9

[/, 2]

[+, 1]

11


133

1. Empiler ([(, 4])2. Inserer ([1, 0])3. Empiler ([+, 1])4. Inserer ([3, 0])5. Empiler ([*, 2])6. Inserer ([4, 0])7. Depiler ([*, 2]); inserer ([*, 2]); Depiler ([+, 1]); insérer ([+, 1]),

Empiler ([+, 1])8. Inserer ([2, 0])9. Depiler ([+, 1]); inserer ([+, 1]); Depiler ([(, 4])10. Empiler ([*, 2])11. Inserer ([5, 0])12. Depiler ([*, 2]); inserer ([*, 2]);

[(, 4]

1 [(, 4]

3

[+, 1]

[(, 4]

5

[+, 1][*, 2]

[(, 4]

7

[+, 1]

� Exemple 3: (1+3*4+2)*5 �134*+2+5*

[*, 2]

10


134

� Transformation infixée �� postfixée (Pseudo Algorithme):

Lire l’expression infixée terme par terme:

Si c'est un opérande alors on insère dans la liste Lpostfixée

Si c’est une parenthèse ouvrante alors on doit l’empiler tout le

temps.

Si c’est une parenthèse fermante alors on doit dépiler jusqu'à

trouver la parenthèse ouvrante associée. Les éléments dépilés sont

insérés dans la liste Lpostfixée

Si c'est un opérateur,

Si la pile est vide ou si l'opérateur est plus prioritaire que

l'opérateur en sommet de pile, alors on l'empile.

Sinon, on dépile jusqu'à pouvoir l'empiler. Les éléments dépilés

sont insérés dans la liste Lpostfixée


135

� Transformation infixée �� postfixée (Déclaration):




Prio : {0,1, 2, 3, 4};

Fin

Type Maillon = structure

Val : Terme;

Suiv : *Maillon ;

Fin

Type Pile= structure

Elements : tableau[Max] de Terme

Sommet : entier

Fin

Prio Signification

0 Opérande





136

� Transformation infixée �� postfixée (Algorithme):


InfixeAPostfixe( Linfixe: *Maillon) : *MaillonVar P: Pile; Lpostfixe, Q:*Maillon; X, Y: TermeDebut

Lpostfixe �Nil; Q�Linfixe; InitPile(P)Tant que (Q≠Nil) faire

X �valeur (Q);Si X.prio = 0 alors InsererLLCFin (Lpostfixe, X) FSISi X.op ='(‘ alors Empiler(P, X) FSISi X.op = ‘)’ alors // depiler (et ecrire ...) jusqu'a l'ouvranteTant que P.Elements[P.Sommet]≠ ‘(‘ faire

depiler(P, Y); InsererLLCFin (Lpostfixe, Y)FTQdepiler(P,Y) // et depiler l'ouvrante !FSI

137

� Transformation infixée �� postfixée (Algorithme):


Si X.prio = 1 , 2 ou 3 alors //c’est un operateurTant que (non Pilevide(P)) et (P.Elements[P.Sommet]≠ ‘(‘ ) et (P.Elements[P.Sommet].prio ≤X.prio) faire

depiler(P,Y)InsererLLCFin (Lpostfixe, Y)

FTQEmpiler(T[i].valeur,P)

FSIQ�suivant (Q);

FTQ// maintenant vider la pileTant que non Pilevide(P) faire

depiler(P,Y)InsererLLCFin (Lpostfixe, Y)

FTQRetourner (Lpostfixe)

Fin

138

3. Donner l’algorithme d’évaluation d’une expression

postfixée.

� Exemples illustratif:


Expressions en

infixée

Expressions en

postfixée

Evaluation

5 *(((9+8)*(4*6))+7) 5 98*46**7+* 2075

~3+2-5*6/2+3 3~2+56*2/-3+ -13

(1+3*4+2)*5 134*+2+5* 75

139

1. empiler(5)

2. empiler(9)

3. empiler(8)

4. depiler (8); depiler (9); empiler(9 + 8)

5. empiler(4)

6. empiler(6)

7. depiler (6); depiler (4); empiler(4*6)

8. depiler (24); depiler (17); empiler( 17 * 24 )

9. empiler(7)

10. depiler (7); depiler (408); empiler(408+7)

11. depiler (415); depiler (5); empiler( 5*415)

12. depiler(2075)5

415

« 10 »

2075

« 11 »

54087

« 9 »

5408

« 8 »

5174

« 5 »5

1746

« 6 »5

1724

« 7 »

5

« 1 »

59

« 2 »

598

« 3 »5

17

« 4 »

� Exemple 1: 598+46**7+* = 2075


140

1. empiler(3)2. depiler(3) ; empiler(0-3)3. empiler(2)4. depiler (2); depiler (-3); empiler( -3 + 2)5. empiler(5)6. empiler(6)7. depiler (6); depiler (5); empiler(5*6)8. empiler(2)9. depiler (2); depiler (30); empiler(30/2)10. depiler (15); depiler (-1); empiler(-1-15)11. empiler (3)12. depiler (3); depiler (-16); empiler(-16+3)13. depiler (-13)

-130

« 7 »

-1302

« 8 »

3« 1 »

-3« 2 »

-32

« 3 »

56

-1

« 4-6 »

-115

« 9 »

3-16

« 10 »

-13« 12 »


� Exemple 2: 3~2+56*2/-3+ = -13

141

1. empiler(1)

2. empiler(3)

3. empiler(4)

4. depiler (4); depiler (3); empiler( 3 * 4)


6. empiler(2)


8. empiler(5)

9. depiler (5); depiler (15); empiler(15*5)

10. depiler (75)

5

13

« 5 »

132

« 6 »

1« 1 »

13

« 2 »

112

« 4 »

15« 7-8 »

75« 9 »

« 3 »134


� Exemple 3: 134*+2+5* = 75

142

� Evaluation d'une expression postfixée (Pseudo Algorithme)

Lire l’expression postfixée terme par terme:

Si c’est un opérande alors on l’empile

Si c’est un opérateur alors

Si c’est un opérateur unaire (moins unaire) alors on dépile

une fois, on multiple par (-1) ensuite on empile le résultat

Si c’est opérateur binaire alors on dépile deux fois, on fait le

calcul correspondant, ensuite on empile le résultat.

A la fin : Le résultat final se trouve au sommet de pile


143

� Evaluation d'une expression postfixée (Déclaration)




Prio : {0,1, 2, 3, 4};

Fin

Type Maillon = structure

Val : Terme;

Suiv : *Maillon ;

Fin

Type Pile1= structure

Elements : tableau[Max] de chaines de caractères

Sommet : entier

Fin

Prio Signification

0 Opérande





144

� Evaluation d'une expression postfixée (Fonction Calcul)


Procédure Calcul (op : caractère, op1, op2, res : chaines de caractères)Var X, Y, Z : entierDebut// convertir les opérandes en entier

X �ConvertirChaineEntier(op1) ;Y �ConvertirChaineEntier(op2) ;//réaliser l’opération correspondante

Selon opCas ‘+’: Z�X+YCas ‘-’: Z�X-YCas ‘*’: Z�X*YCas ‘/’: Z�X/YCas ‘%’: Z�X%YFinselon//convertir le résultat en chaîne de caractère

Res �ConvertirEntierChaine(Z)Fin

� Evaluation d'une expression postfixée (Algorithme)


EVAL_Postfixe( L: *Maillon) : entierInitpile(P); Q�LpostfixeTant que (Q≠Nil) faire

X�valeur (Q)Si (X.prio=0) alors Empiler( P, X.op) //opérandeSinon /* donc c'est un opérateur */

Si (X.prio=3) // moins unaireDepiler(P,Y); Calcul(‘*’,‘-1’, Y, Y); Empiler(P, Y)

SinonSi (X.prio=1) ou (X.prio=2) alors /* donc opérateur binaire */

Depiler(P,b); Depiler(P,a); Calcul(X.op, a, b, a); Empiler( P, a)

Q�suivant (Q)FTQDepiler( P, res ) // le résultat se trouve au sommetRetourner (ConvertirChaineEntier (res))

� Evaluation d'une expression postfixée (Algorithme)

145

SOURCES DE CE COURS

� N. EL-ALLIA , Cours d’Algorithmique et Structures de données

dynamiques, Ecole nationale Supérieure d’Informatique (ESI), 2010.

� Djamel Eddine ZEGOUR, Cours de Structures de Données, Ecole nationale

Supérieure d’Informatique (ESI), Disponible sur

http://zegour.esi.dz/Cours/Cours_sdd.htm

� B. Boutoumi, , Cours d’Algorithmique et Structures de données, Université

Saad Dahlab de Blida, 2014, Disponible sur

https://sites.google.com/a/esi.dz/s-aroussi/algorithmique-et-structure-de-

donnees/nouveau-programme .

� A. Djeffal, Cours d’Algorithmique et Structures de données 1, Université

Mohamed Khider de Biskra, 2012, Disponible sur univ-

biskra.dz/fac/fsesnv/cours/algo 146

Chapitre 3 structures séquentielles

Education

Transcript of Chapitre 3 structures séquentielles