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 nouveau
maillon 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 » du
maillon pointé par P (retourner (*P.val))
Suivant(P)
C’est une fonction qui retourne le contenu du champs « suiv » du
maillon 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, Q
void 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 vide
DTQ
écrire (valeur (P))
P ←suivant (P)
FTQ
Fin

18
La longueur de cette liste = 5
LONGUEUR
2 10 5 -1 6
L
Fonction LongLLC (L:*maillon): entier
Début
P L; Cpt 0;
DTQ
Cpt ++
P ←suivant (P)
FTQ
Retourner (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): *maillon
Début
P ←L
DTQ
Si valeur (P) = v alors
retourner (P)
Sinon
P ←suivant (P)
FTQ
Retourner (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): *maillon
Debut
P ←L; i ←1
Tant que (i<K) et (P≠nil) faire //accéder au K ème maillon
DTQ
i++; P ←suivant (P);
FTQ
Retourner (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
P
aff_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 liste
Fin

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ête
Sinon
Dsinon
Q ←L
Tant 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
INSERTION
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 faux
Si (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 existe
Allouer (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
L
Q
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)
Sinon
aff_suiv(Q, P)
Q←P //sauvegarder l’@ du dernier maillon
FP
Fin
Procédure CreerLLC (L:*maillon)
Début
DP
lire (v)
InsererLLC_Fin(L, v)
FP
Fin

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
P
aff_suiv (P, L)
Procédure CreerLLC_inverse (L:*maillon)
Début
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
FP
Fin
Procédure CreerLLC_inversé (L:*maillon)
Début
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)
FTQ
Si (P ≠ nil) alors
Si Q = nil alors
L ← 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 nil
TQ (P ≠≠≠≠ nil)
TQ ((P ≠ nil) et (valeur (P) ≠ v) )
Q←P; P ←suivant (P)
FTQ
Si (P ≠ nil) alors
Si Q = nil alors
L ← 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 faux
Si (k>0) alors
Si (k = 1) alors // supprimer le premier maillon
P←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 vide
DTQ
P←L
L ←suivant (L)
libérer (P)
FTQ
Fin
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←L
Répéter
Écrire (valeur (P))
P ←suivant(P)
Jusqu’à P=L
Fin
P

38
Recherche le premier maillon contenant la valeur v
2 10 5 -1L
Fonction RechLLC_cir (L:*maillon, v:entier): *maillon
Début
Si L ≠ nil alors
P←L
Ré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)
aff_suiv(P, P)
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
lire (x)
Allouer (P); aff_val(P, x)
Si (L=nil) alors L ←P // mettre à jour l’entête
Sinon aff_suiv(Q, P)
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
lire (x); Allouer (P); aff_val(P, x)
Sinon
aff_suiv(Q, P)
aff_suiv(P, L)// lier le dernier maillon au premier
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←L
répéter
Q←P
P ←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 L
Si P = Q alors // la liste contient un seul maillon
L ← nil
Sinon
L ← suivant (P); aff_suiv(Q,suivant (P))
Sinon
aff_suiv(Q,suivant (P))
libérer (P)
Fin
//rechercher le maillon
contenant 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)
FTQ
Libé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.Tete
Tant 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: ListeBD
Début
Q L.Queue
Tant 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): *MaillonBD
Début
P ←L.Tete
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): *MaillonBD
Début
P ←L.Queue
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): *maillonBD
Debut
P ←L.Tete; i ←1
Tant que (i<K) et (P≠nil) faire //accéder au K ème maillon
DTQ
i++; P ←suivant (P);
FTQ
Retourner (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
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
QueueS
6
(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 ≠ Nil
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)
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)
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 maillon
Init (L)// T ←←←←nil; Q ←←←←nil i.e. la liste devient vide
Sinon Si P = L.Tete alors //suppression au début
L.Tete ← suivant (P); aff_prec(L.Tete, nil);
Sinon Si P = L.Queue alors //suppression à la fin
L.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.Tete
Tant que (T≠nil) faire
P←T
T ←←←←suivant (T)
libérer (P)
Init (L);
Fin
Procédure DetruireLLCbd (Var L: ListeBD)
Début
Q L.Queue
Tant que (Q≠nil) faire
P←Q
Q ←←←←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 = Structure
vide : Booléen
val : typeqq
suiv : Entier
fin
var Liste : tableau [Max] de element
Tête = 0
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 le
tableau L du taille max sinon la valeur -1 s'il n’y a pas de
place.
Libérer(L,P)
C’est une procédure qui positionne le champs « vide » de la
case 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]
MODÈLE

62
Modules Code Complexité
Allouer(L, max) Pour i←0 à max-1 faire
Si L[i].Vide alors
L[i] ←faux
Retourner(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)
MODÈ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:
Implicite
définie par la contiguïté
des composantes du
tableau
Explicite
On 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

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é ) faire
I←I+1
//décaler les programmes moins prioritaires
J F.Queue
TQ (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)
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é ) faire
F.Elements[I+1] ← F.Elements[I]
I←I-1
F.Elements[I] ← X

92
3ème méthode: Enfiler(F,X)
F.Elements[F.Queue] ← X
//trier le tableau d’éléments
I ← F.Queue -1
TQ (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)
F.Queue ← (F.Queue + 1) mod Max
F.Elements[F.Queue] ← X
I ← F.Queue
Si I=0 alors J Max-1; Sinon J I-1
TQ (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] ← Tmp
Si I=0 alors I Max-1; Sinon I I-1
Si 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)
F.Elements[F.Tete] ← X
I ← F..Tete
J (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)

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épilement
Empilement
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 entre
parenthèses:
accepter les mots comme (), ()(()) ou ((()())()) ;
rejeter les mots comme )(, ()(() ou ((()()))).
Pour le résoudre, on stocke les parenthèses ouvrantes non encore
refermées dans une pile de caractères. Autrement dit, on lit caractère
par 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])
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])
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) : *Maillon
Var P: Pile; Lpostfixe, Q:*Maillon; X, Y: Terme
Debut
Lpostfixe Nil; Q Linfixe; InitPile(P)
Tant que (Q≠Nil) faire
X valeur (Q);
Si X.prio = 0 alors InsererLLCFin (Lpostfixe, X) FSI
Si X.op ='(‘ alors Empiler(P, X) FSI
Si X.op = ‘)’ alors // depiler (et ecrire ...) jusqu'a l'ouvrante
Tant que P.Elements[P.Sommet]≠ ‘(‘ faire
depiler(P, Y); InsererLLCFin (Lpostfixe, Y)
FTQ
depiler(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 operateur
Tant que (non Pilevide(P)) et (P.Elements[P.Sommet]≠ ‘(‘ )
et (P.Elements[P.Sommet].prio ≤X.prio) faire
depiler(P,Y)
InsererLLCFin (Lpostfixe, Y)
FTQ
Empiler(T[i].valeur,P)
FSI
Q suivant (Q);
FTQ
// maintenant vider la pile
Tant que non Pilevide(P) faire
depiler(P,Y)
InsererLLCFin (Lpostfixe, Y)
FTQ
Retourner (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 »
5
408
7
« 9 »
5
408
« 8 »
5
17
4
« 5 »
5
17
4
6
« 6 »
5
17
24
« 7 »
5
« 1 »
5
9
« 2 »
5
9
8
« 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)
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)
-1
30
« 7 »
-1
30
2
« 8 »
3
« 1 »
-3
« 2 »
-3
2
« 3 »
5
6
-1
« 4-6 »
-1
15
« 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)
10. depiler (75)
5
13
« 5 »
13
2
« 6 »
1
« 1 »
1
3
« 2 »
1
12
« 4 »
15
« 7-8 »
75
« 9 »
« 3 »
1
3
4
Exemple 3: 134*+2+5* = 75

14
2
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

14
3
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 : entier
Debut
// convertir les opérandes en entier
X ConvertirChaineEntier(op1) ;
Y ConvertirChaineEntier(op2) ;
//réaliser l’opération correspondante
Selon op
Cas ‘+’: Z X+Y
Cas ‘-’: Z X-Y
Cas ‘*’: Z X*Y
Cas ‘/’: Z X/Y
Cas ‘%’: Z X%Y
Finselon
//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) : entier
Initpile(P); Q Lpostfixe
Tant que (Q≠Nil) faire
X valeur (Q)
Si (X.prio=0) alors Empiler( P, X.op) //opérande
Sinon /* donc c'est un opérateur */
Si (X.prio=3) // moins unaire
Depiler(P,Y); Calcul(‘*’,‘-1’, Y, Y); Empiler(P, Y)
Sinon
Si (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)
FTQ
Depiler( P, res ) // le résultat se trouve au sommet
Retourner (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

Contenu connexe

Tendances

En vedette

Similaire à Chapitre 3 structures séquentielles

Plus de Sana Aroussi

Dernier

Chapitre 3 structures séquentielles