SlideShare une entreprise Scribd logo
1  sur  146
Télécharger pour lire hors ligne
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.
ALGORITHMES SUR LES LLCS
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.
ALGORITHMES SUR LES LLCS
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.
ALGORITHMES SUR LES LLCS
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.
ALGORITHMES SUR LES LLCS
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
ALGORITHMES SUR LES LLCS
17
Soient la liste suivante:
La liste imprimée est 2, 10, 5, -1 et 6
ALGORITHMES SUR LES LLCS
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
Soient la liste suivante:
La longueur de cette liste = 5
ALGORITHMES SUR LES LLCS
LONGUEUR
2 10 5 -1 6
L
Fonction LongLLC (L:*maillon): entier
Début
P L; Cpt 0;
Tant que (P≠nil) faire // la liste n’est pas vide
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.
ALGORITHMES SUR LES LLCS
RECHERCHE
2 10 5 -1 6
L
Fonction RechLLC (L:*maillon, v:entier): *maillon
Début
P ←L
Tant que (P≠nil) faire // la liste n’est pas vide
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)
ALGORITHMES SUR LES LLCS
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
ALGORITHMES SUR LES LLCS
INSERTION
22
Cas 1: Insertion au début
ALGORITHMES SUR LES LLCS
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.
ALGORITHMES SUR LES LLCS
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;
ALGORITHMES SUR LES LLCS
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 LLCS
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
ALGORITHMES SUR LES LLCS
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
ALGORITHMES SUR LES LLCS
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)
Si (L=nil) alors //la liste est vide
L ←P // mettre à jour l’entête
Sinon
aff_suiv(Q, P)
Q←P //sauvegarder l’@ du dernier maillon
FP
Fin
Procédure CreerLLC (L:*maillon)
Début
Pour i←1 à N faire
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
ALGORITHMES SUR LES LLCS
CRÉATION
-1 5 10 2
6
L
P
aff_suiv (P, L)
Procédure CreerLLC_inverse (L:*maillon)
Début
Pour 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
FP
Fin
Procédure CreerLLC_inversé (L:*maillon)
Début
Pour 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.
ALGORITHMES SUR LES LLCS
SUPPRESSION
30
Exemple 1: Suppression v = 5
Exemple 2 : Suppression v = 2
ALGORITHMES SUR LES LLCS
SUPPRESSION
2 10 5 -1 6
L
2 10 5 -1 6
PL
2 10 5 -1
L Q P
6
Q
31
ALGORITHMES SUR LES LLCS
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
ALGORITHMES SUR LES LLCS
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;
ALGORITHMES SUR LES LLCS
SUPPRESSION
2 10 5 -1
L Q
k
P
34
Suppression à une position donné « k ».
ALGORITHMES SUR LES LLCS
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
Soient la liste suivante:
ALGORITHMES SUR LES LLCS
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
LISTES PARTICULIÈRES
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
LISTES PARTICULIÈRES
LISTE CIRCULAIRE (QUELQUES ALGORITHMES)
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
LISTES PARTICULIÈRES
LISTE CIRCULAIRE (QUELQUES ALGORITHMES)
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 vide
aff_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
LISTES PARTICULIÈRES
LISTE CIRCULAIRE (QUELQUES ALGORITHMES)
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ête
Sinon aff_suiv(Q, P)
Q←P //sauvegarder l’@ du dernier maillon
aff_suiv (P, L);
Fin
Q P
41
Construction d’une LLC circulaire
LISTES PARTICULIÈRES
LISTE CIRCULAIRE (QUELQUES ALGORITHMES)
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
L ←P // mettre à jour l’entête
Sinon
aff_suiv(Q, P)
aff_suiv(P, L)// lier le dernier maillon au premier
Q←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
LISTES PARTICULIÈRES
LISTE CIRCULAIRE (QUELQUES ALGORITHMES)
2 10 5 -1L
43
Suppression du maillon contenant la valeur v
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
LISTES PARTICULIÈRES
LISTE CIRCULAIRE (QUELQUES ALGORITHMES)
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.
LISTES PARTICULIÈRES
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.
LISTES PARTICULIÈRES
LISTE BIDIRECTIONNELLE
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 }
LISTES PARTICULIÈRES
LISTE BIDIRECTIONNELLE
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
LISTES PARTICULIÈRES
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
LISTES PARTICULIÈRES
LISTE BIDIRECTIONNELLE (QUELQUES ALGORITHMES)
Fonction RechLLCbd(L: ListeBD, v:entier): *MaillonBD
Début
P ←L.Tete
Tant 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): *MaillonBD
Début
P ←L.Queue
Tant 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
LISTES PARTICULIÈRES
LISTE BIDIRECTIONNELLE (QUELQUES ALGORITHMES)
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
LISTES PARTICULIÈRES
LISTE BIDIRECTIONNELLE (QUELQUES ALGORITHMES)
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.
LISTES PARTICULIÈRES
LISTE BIDIRECTIONNELLE (QUELQUES ALGORITHMES)
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
LISTES PARTICULIÈRES
LISTE BIDIRECTIONNELLE (QUELQUES ALGORITHMES)
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
Allouer (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
LISTES PARTICULIÈRES
LISTE BIDIRECTIONNELLE (QUELQUES ALGORITHMES)
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
LISTES PARTICULIÈRES
LISTE BIDIRECTIONNELLE (QUELQUES ALGORITHMES)
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
Suppression du maillon contenant la valeur v
LISTES PARTICULIÈRES
LISTE BIDIRECTIONNELLE (QUELQUES ALGORITHMES)
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
LISTES PARTICULIÈRES
LISTE BIDIRECTIONNELLE (QUELQUES ALGORITHMES)
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
LISTES PARTICULIÈRES
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
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 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]
REPRÉSENTATION CONTIGÜE
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)
REPRÉSENTATION CONTIGÜE
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
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
IMPLÉMENTATION STATIQUE PAR DÉCALAGE
Définition de la structure :
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
IMPLÉMENTATION STATIQUE PAR DÉCALAGE
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
IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE
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
IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE
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
IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE
Définition de la structure :
TYPE File_Attente = STRUCTURE
Elements : TABLEAU[Max] de Typeqq
Tête, Queue : ENTIER
FIN
VAR F : File_Attente
File_Attente
Eléments
V2 V3 V4 V5
Tête = 1 Queue = 5
80
IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE
Modèle Implémentation
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
Defiler(F,X) SI (NON Filevide(F))
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
IMPLÉMENTATION DYNAMIQUE
V0 V1 V2 V3 V4
Tête Queue
Définition de la structure :
TYPE Maillon = STRUCTURE
val : typeqq
suiv: * Maillon
FIN
TYPE File_Attente = STRUCTURE
Tête, Queue : *Maillon
FIN
VAR F: File_Attente
File_Attente
83
IMPLÉMENTATION DYNAMIQUE
Modèle Implémentation
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
Defiler(F,X) SI (NON Filevide(F))
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).
FILE D’ATTENTE AVEC PRIORITÉ
86
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR DÉCALAGE
Définition de la structure :
TYPE prog = STRUCTURE
prio : ENTIER
PSW : typeqcq
FIN
TYPE File_Attente = STRUCTURE
Elements : TABLEAU[Max] de prog
Queue : ENTIER
FIN
(3,
PSW)
(2,
PSW)
(1,
PSW)
(1,
PSW)
(0,
PSW)
Queue
87
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR DÉCALAGE
Modèle Implémentation
Initfile(F) F.Queue ←-1
Filevide(F) Retourner (F.Queue = -1)
Filepleine(F) Retourner (F.Queue = Max-1)
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
88
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR DÉCALAGE
(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
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR DÉCALAGE
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
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR DÉCALAGE
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
F.Queue ← F.Queue + 1
91
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR DÉCALAGE
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é ) faire
F.Elements[I+1] ← F.Elements[I]
I←I-1
//insérer le programme X
F.Elements[I] ← X
//mettre à jour la queue
F.Queue ← F.Queue + 1
92
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR DÉCALAGE
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 -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
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE
Définition de la structure :
TYPE prog = STRUCTURE
prio : ENTIER
PSW : typeqcq
FIN
TYPE File_Attente = STRUCTURE
Elements : TABLEAU[Max] de prog
Queue, Tete : ENTIER
FIN
(3,
PSW)
(2,
PSW)
(1,
PSW)
(1,
PSW)
(0,
PSW)
TeteQueue
94
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE
Modèle Implémentation
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
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE
(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
Tete
Tete
96
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE
(1,
PSW)
(0,
PSW)
(3,
PSW)
(2,
PSW)
(1,
PSW)
Queue
Enfiler (F, (2, PSW))
Tete
(1,
PSW)
(1,
PSW)
(0,
PSW)
(3,
PSW)
(2,
PSW)
(2,
PSW)
Queue Tete
97
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE
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
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE
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
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE
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.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
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE
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) Décrémentation des indices!!
4ème méthode: insérer le nouvel élément à la tête ensuite
essayer de trier le tableau en faisant des permutations
(principe de tri par insertion)
101
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE
(2,
PSW)
(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
Tete
Tete
102
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE
(2,
PSW)
(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
Tete
Tete
103
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE
(3,
PSW)
(2,
PSW)
(1,
PSW)
(1,
PSW)
(0,
PSW)
(2,
PSW)
Queue
Enfiler (F, (2, PSW))
(2,
PSW)
(2,
PSW)
(1,
PSW)
(1,
PSW)
(0,
PSW)
(3,
PSW)
Queue
Tete
Tete
104
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE
(1,
PSW)
(0,
PSW)
(2,
PSW)
(3,
PSW)
(2,
PSW)
(1,
PSW)
Queue
Enfiler (F, (2, PSW))
Tete
(1,
PSW)
(0,
PSW)
(3,
PSW)
(2,
PSW)
(2,
PSW)
(1,
PSW)
Queue Tete
105
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE
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..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
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION DYNAMIQUE
(3,PSW)
Tête Queue
(2,PSW) (1,PSW) (1,PSW) (0,PSW)
Définition de la structure :
TYPE prog = STRUCTURE
prio : ENTIER
PSW : typeqcq
FIN
TYPE Maillon = STRUCTURE
val : prog
suiv: * Maillon
FIN
TYPE File_Attente = STRUCTURE
TêTe, Queue : *Maillon
FIN
107
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION DYNAMIQUE
Modèle Implémentation
Initfile(F) F.Tete ← NIL
F.Queue← NIL
Filevide(F) Retourner (F.Tete = NIL )
Defiler(F,X) SI (NON Filevide(F))
P ← F.Tete
X ← Valeur(F.Tete)
F.Tete ← Suivant(F.Tete)
Liberer(P)
108
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION DYNAMIQUE
Enfiler (F, (2, PSW))
(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
FILE D’ATTENTE AVEC PRIORITÉ
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épilement
Empilement
0
max-1
117
IMPLÉMENTATION STATIQUE PAR DÉCALAGE
Définition de la structure :
TYPE Pile= STRUCTURE
Elements : TABLEAU[Max] de Typeqq
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
IMPLÉMENTATION DYNAMIQUE
V4 V3 V2 V1 V0
Sommet (Tête)
Empilement
Dépilement
120
IMPLÉMENTATION DYNAMIQUE
V4 V3 V2 V0 V1
Sommet
Définition de la structure :
TYPE Maillon = STRUCTURE
val : typeqq
suiv: * Maillon
FIN
VAR sommet: *Maillon
Pile
121
IMPLÉMENTATION DYNAMIQUE
Modèle Implémentation
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*
EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
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
EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
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).
EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
[‘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+*
EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
129
3. Ecrire l’algorithme qui permet de transformer une
expression infixée en une expression postfixée.
Exemples illustratif:
EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
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]
EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
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]
EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
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
EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
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
EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
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
EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
135
Transformation infixée postfixée (Déclaration):
EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
Type Terme = structure
Op : Chaines de caractères;
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
1 Opérateur binaire (+, -)
2 Opérateur binaire ( *, /, %)
3 Opérateur unaire ( - unaire)
4 Parenthèse ouvrante ou fermante
136
Transformation infixée postfixée (Algorithme):
EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
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):
EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
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:
EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
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
EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
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)
-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 »
EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
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)
5. depiler (12); depiler (1); empiler(1+12)
6. empiler(2)
7. depiler (2); depiler (13); empiler(13+2)
8. empiler(5)
9. depiler (5); depiler (15); empiler(15*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
EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
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
EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
14
3
Evaluation d'une expression postfixée (Déclaration)
EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
Type Terme = structure
Op : Chaines de caractères;
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
1 Opérateur binaire (+, -)
2 Opérateur binaire ( *, /, %)
3 Opérateur unaire ( - unaire)
4 Parenthèse ouvrante ou fermante
144
Evaluation d'une expression postfixée (Fonction Calcul)
EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
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)
EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
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

Contenu connexe

Tendances

Telecharger Exercices corrigés PL/SQL
Telecharger Exercices corrigés PL/SQLTelecharger Exercices corrigés PL/SQL
Telecharger Exercices corrigés PL/SQLwebreaker
 
Cours python avancé
Cours python avancéCours python avancé
Cours python avancépierrepo
 
Merise+ +exercices+mcd+-+corrigés
Merise+ +exercices+mcd+-+corrigésMerise+ +exercices+mcd+-+corrigés
Merise+ +exercices+mcd+-+corrigésMajid CHADAD
 
Fonctions chaine
Fonctions chaineFonctions chaine
Fonctions chaineAfef Ilahi
 
Chapitre1: Langage Python
Chapitre1: Langage PythonChapitre1: Langage Python
Chapitre1: Langage PythonAziz Darouichi
 
Introduction à l’orienté objet en Python
Introduction à l’orienté objet en PythonIntroduction à l’orienté objet en Python
Introduction à l’orienté objet en PythonAbdoulaye Dieng
 
Base de donnees Avancees et Intro à NoSQL.ppt
Base de donnees Avancees et Intro à  NoSQL.pptBase de donnees Avancees et Intro à  NoSQL.ppt
Base de donnees Avancees et Intro à NoSQL.pptIdriss22
 
BigData_TP3 : Spark
BigData_TP3 : SparkBigData_TP3 : Spark
BigData_TP3 : SparkLilia Sfaxi
 
Présentation python
Présentation pythonPrésentation python
Présentation pythonSarah
 
Cours Algorithme: Matrice
Cours Algorithme: MatriceCours Algorithme: Matrice
Cours Algorithme: MatriceInforMatica34
 
Chapitre5 les chaînes de caractères - Copy.pptx
Chapitre5 les chaînes de caractères - Copy.pptxChapitre5 les chaînes de caractères - Copy.pptx
Chapitre5 les chaînes de caractères - Copy.pptxFerdawsBNasrBSalah
 
Cours Big Data Chap5
Cours Big Data Chap5Cours Big Data Chap5
Cours Big Data Chap5Amal Abid
 
BigData_TP4 : Cassandra
BigData_TP4 : CassandraBigData_TP4 : Cassandra
BigData_TP4 : CassandraLilia Sfaxi
 
LUP IRT 2021_2022 - Cours - Programmation Python (Partie I).pdf
LUP IRT 2021_2022 - Cours - Programmation Python (Partie I).pdfLUP IRT 2021_2022 - Cours - Programmation Python (Partie I).pdf
LUP IRT 2021_2022 - Cours - Programmation Python (Partie I).pdfRedaBelattar
 

Tendances (20)

Telecharger Exercices corrigés PL/SQL
Telecharger Exercices corrigés PL/SQLTelecharger Exercices corrigés PL/SQL
Telecharger Exercices corrigés PL/SQL
 
Cours python avancé
Cours python avancéCours python avancé
Cours python avancé
 
Merise+ +exercices+mcd+-+corrigés
Merise+ +exercices+mcd+-+corrigésMerise+ +exercices+mcd+-+corrigés
Merise+ +exercices+mcd+-+corrigés
 
Fonctions chaine
Fonctions chaineFonctions chaine
Fonctions chaine
 
Introduction à Python
Introduction à PythonIntroduction à Python
Introduction à Python
 
Chapitre1: Langage Python
Chapitre1: Langage PythonChapitre1: Langage Python
Chapitre1: Langage Python
 
Introduction à l’orienté objet en Python
Introduction à l’orienté objet en PythonIntroduction à l’orienté objet en Python
Introduction à l’orienté objet en Python
 
Base de donnees Avancees et Intro à NoSQL.ppt
Base de donnees Avancees et Intro à  NoSQL.pptBase de donnees Avancees et Intro à  NoSQL.ppt
Base de donnees Avancees et Intro à NoSQL.ppt
 
Chap1: Cours en C++
Chap1: Cours en C++Chap1: Cours en C++
Chap1: Cours en C++
 
Serie2
Serie2Serie2
Serie2
 
BigData_TP3 : Spark
BigData_TP3 : SparkBigData_TP3 : Spark
BigData_TP3 : Spark
 
Présentation python
Présentation pythonPrésentation python
Présentation python
 
Programmation en C
Programmation en CProgrammation en C
Programmation en C
 
02 correction-td smi-s3-algo2
02 correction-td smi-s3-algo202 correction-td smi-s3-algo2
02 correction-td smi-s3-algo2
 
01 correction-td smia-s2-info2
01 correction-td smia-s2-info201 correction-td smia-s2-info2
01 correction-td smia-s2-info2
 
Cours Algorithme: Matrice
Cours Algorithme: MatriceCours Algorithme: Matrice
Cours Algorithme: Matrice
 
Chapitre5 les chaînes de caractères - Copy.pptx
Chapitre5 les chaînes de caractères - Copy.pptxChapitre5 les chaînes de caractères - Copy.pptx
Chapitre5 les chaînes de caractères - Copy.pptx
 
Cours Big Data Chap5
Cours Big Data Chap5Cours Big Data Chap5
Cours Big Data Chap5
 
BigData_TP4 : Cassandra
BigData_TP4 : CassandraBigData_TP4 : Cassandra
BigData_TP4 : Cassandra
 
LUP IRT 2021_2022 - Cours - Programmation Python (Partie I).pdf
LUP IRT 2021_2022 - Cours - Programmation Python (Partie I).pdfLUP IRT 2021_2022 - Cours - Programmation Python (Partie I).pdf
LUP IRT 2021_2022 - Cours - Programmation Python (Partie I).pdf
 

En vedette

Chapitre iii récursivité et paradigme diviser pour régner
Chapitre iii récursivité et paradigme diviser pour régnerChapitre iii récursivité et paradigme diviser pour régner
Chapitre iii récursivité et paradigme diviser pour régnerSana Aroussi
 
Atelier veille et prospection en btob nouvelles techniques - 14112013 - dif...
Atelier   veille et prospection en btob nouvelles techniques - 14112013 - dif...Atelier   veille et prospection en btob nouvelles techniques - 14112013 - dif...
Atelier veille et prospection en btob nouvelles techniques - 14112013 - dif...echangeurba
 
Kit présentation rapport ambition numérique
Kit présentation rapport ambition numériqueKit présentation rapport ambition numérique
Kit présentation rapport ambition numériqueCNNum
 
Chapitre i rappel sur l'algèbre de boole
Chapitre i rappel sur l'algèbre de boole Chapitre i rappel sur l'algèbre de boole
Chapitre i rappel sur l'algèbre de boole Sana Aroussi
 
Plaquette produits fauteuil acapulco
Plaquette produits fauteuil acapulcoPlaquette produits fauteuil acapulco
Plaquette produits fauteuil acapulcoJulien ADAM
 
Think Digital groupe de réflexion édition numérique session 2 : Alain Pierrot...
Think Digital groupe de réflexion édition numérique session 2 : Alain Pierrot...Think Digital groupe de réflexion édition numérique session 2 : Alain Pierrot...
Think Digital groupe de réflexion édition numérique session 2 : Alain Pierrot...Jean-Baptiste Soufron
 
BOQA - FR - Catalogue 2016
BOQA - FR - Catalogue 2016BOQA - FR - Catalogue 2016
BOQA - FR - Catalogue 2016Nicolas Garet
 
Anti viraux et immunomodulateurs.ppt
Anti viraux et immunomodulateurs.pptAnti viraux et immunomodulateurs.ppt
Anti viraux et immunomodulateurs.pptodeckmyn
 
Rapport de stage : Étudier le principe de fonctionnement des capteurs de régu...
Rapport de stage : Étudier le principe de fonctionnement des capteurs de régu...Rapport de stage : Étudier le principe de fonctionnement des capteurs de régu...
Rapport de stage : Étudier le principe de fonctionnement des capteurs de régu...Abdo07
 
Presentación TT Javier Calvo
Presentación TT Javier CalvoPresentación TT Javier Calvo
Presentación TT Javier CalvoeiciUV
 
Oracle Forms
Oracle FormsOracle Forms
Oracle Formshenryjzbl
 
2009 Présentation préparé par un citoyen a Sanimax
2009 Présentation préparé par un citoyen a Sanimax 2009 Présentation préparé par un citoyen a Sanimax
2009 Présentation préparé par un citoyen a Sanimax CleanUpSanimax
 
Le Moteur A Hydrogene
Le Moteur A HydrogeneLe Moteur A Hydrogene
Le Moteur A HydrogeneCinemaTICE
 

En vedette (20)

Chapitre 1 rappel
Chapitre 1   rappelChapitre 1   rappel
Chapitre 1 rappel
 
Chapitre iii récursivité et paradigme diviser pour régner
Chapitre iii récursivité et paradigme diviser pour régnerChapitre iii récursivité et paradigme diviser pour régner
Chapitre iii récursivité et paradigme diviser pour régner
 
Atelier veille et prospection en btob nouvelles techniques - 14112013 - dif...
Atelier   veille et prospection en btob nouvelles techniques - 14112013 - dif...Atelier   veille et prospection en btob nouvelles techniques - 14112013 - dif...
Atelier veille et prospection en btob nouvelles techniques - 14112013 - dif...
 
Kit présentation rapport ambition numérique
Kit présentation rapport ambition numériqueKit présentation rapport ambition numérique
Kit présentation rapport ambition numérique
 
faroT
faroTfaroT
faroT
 
Chapitre i rappel sur l'algèbre de boole
Chapitre i rappel sur l'algèbre de boole Chapitre i rappel sur l'algèbre de boole
Chapitre i rappel sur l'algèbre de boole
 
Plaquette produits fauteuil acapulco
Plaquette produits fauteuil acapulcoPlaquette produits fauteuil acapulco
Plaquette produits fauteuil acapulco
 
La Chaine Respiratoire
La Chaine RespiratoireLa Chaine Respiratoire
La Chaine Respiratoire
 
Mon CV
Mon CVMon CV
Mon CV
 
Think Digital groupe de réflexion édition numérique session 2 : Alain Pierrot...
Think Digital groupe de réflexion édition numérique session 2 : Alain Pierrot...Think Digital groupe de réflexion édition numérique session 2 : Alain Pierrot...
Think Digital groupe de réflexion édition numérique session 2 : Alain Pierrot...
 
Rapport de stage
Rapport de stageRapport de stage
Rapport de stage
 
BOQA - FR - Catalogue 2016
BOQA - FR - Catalogue 2016BOQA - FR - Catalogue 2016
BOQA - FR - Catalogue 2016
 
Anti viraux et immunomodulateurs.ppt
Anti viraux et immunomodulateurs.pptAnti viraux et immunomodulateurs.ppt
Anti viraux et immunomodulateurs.ppt
 
Rapport de stage : Étudier le principe de fonctionnement des capteurs de régu...
Rapport de stage : Étudier le principe de fonctionnement des capteurs de régu...Rapport de stage : Étudier le principe de fonctionnement des capteurs de régu...
Rapport de stage : Étudier le principe de fonctionnement des capteurs de régu...
 
Sergiocastillolaclo2008
Sergiocastillolaclo2008Sergiocastillolaclo2008
Sergiocastillolaclo2008
 
Presentación TT Javier Calvo
Presentación TT Javier CalvoPresentación TT Javier Calvo
Presentación TT Javier Calvo
 
OA
OAOA
OA
 
Oracle Forms
Oracle FormsOracle Forms
Oracle Forms
 
2009 Présentation préparé par un citoyen a Sanimax
2009 Présentation préparé par un citoyen a Sanimax 2009 Présentation préparé par un citoyen a Sanimax
2009 Présentation préparé par un citoyen a Sanimax
 
Le Moteur A Hydrogene
Le Moteur A HydrogeneLe Moteur A Hydrogene
Le Moteur A Hydrogene
 

Similaire à Chapitre 3 structures séquentielles

Les listes simplement chaînées en langage C
Les listes simplement chaînées en langage CLes listes simplement chaînées en langage C
Les listes simplement chaînées en langage CMohamed Lahby
 
1- Exercices de révision sur les listes.pptx
1- Exercices de révision sur les listes.pptx1- Exercices de révision sur les listes.pptx
1- Exercices de révision sur les listes.pptxOlyvierNzighou1
 
Oracle : extension du langage SQL
Oracle : extension du langage SQLOracle : extension du langage SQL
Oracle : extension du langage SQLMohammed Jaafar
 
Chapitre8: Collections et Enumerations En Java
Chapitre8: Collections et Enumerations En JavaChapitre8: Collections et Enumerations En Java
Chapitre8: Collections et Enumerations En JavaAziz Darouichi
 
Structure des données complexes . pptx .
Structure des données complexes . pptx .Structure des données complexes . pptx .
Structure des données complexes . pptx .MeriemKeddad
 
Atelier Python 2eme partie par Achraf Kacimi El Hassani
Atelier Python 2eme partie par Achraf Kacimi El HassaniAtelier Python 2eme partie par Achraf Kacimi El Hassani
Atelier Python 2eme partie par Achraf Kacimi El HassaniShellmates
 
Cours_Listes .pdf
Cours_Listes .pdfCours_Listes .pdf
Cours_Listes .pdfDOUA9
 
5- understandinggJava_Collections_v4.pdf
5- understandinggJava_Collections_v4.pdf5- understandinggJava_Collections_v4.pdf
5- understandinggJava_Collections_v4.pdfAliouDiallo24
 
Programmes et objets informatiques (Prof. Ch. Rapin, Juillet 1989)
Programmes et objets informatiques (Prof. Ch. Rapin, Juillet 1989)Programmes et objets informatiques (Prof. Ch. Rapin, Juillet 1989)
Programmes et objets informatiques (Prof. Ch. Rapin, Juillet 1989)ebruchez
 
Nettoyer et transformer ses données avec Openrefine : partie 2
Nettoyer et transformer ses données avec Openrefine : partie 2Nettoyer et transformer ses données avec Openrefine : partie 2
Nettoyer et transformer ses données avec Openrefine : partie 2Mathieu Saby
 
Chapitre 2: String en Java
Chapitre 2:  String en JavaChapitre 2:  String en Java
Chapitre 2: String en JavaAziz Darouichi
 
INF220 - Algo DUT SRC1 - Cours 2
INF220 - Algo DUT SRC1 - Cours 2INF220 - Algo DUT SRC1 - Cours 2
INF220 - Algo DUT SRC1 - Cours 2PGambette
 
cours TRI selection insertion bublle sort
cours TRI selection insertion bublle sortcours TRI selection insertion bublle sort
cours TRI selection insertion bublle sortYounesOuladSayad1
 

Similaire à Chapitre 3 structures séquentielles (20)

Les listes simplement chaînées en langage C
Les listes simplement chaînées en langage CLes listes simplement chaînées en langage C
Les listes simplement chaînées en langage C
 
1- Exercices de révision sur les listes.pptx
1- Exercices de révision sur les listes.pptx1- Exercices de révision sur les listes.pptx
1- Exercices de révision sur les listes.pptx
 
Les listes en Python
Les listes en PythonLes listes en Python
Les listes en Python
 
POO-JAVA-partie-2.pdf
POO-JAVA-partie-2.pdfPOO-JAVA-partie-2.pdf
POO-JAVA-partie-2.pdf
 
Oracle : extension du langage SQL
Oracle : extension du langage SQLOracle : extension du langage SQL
Oracle : extension du langage SQL
 
ch4_les listes.pdf
ch4_les listes.pdfch4_les listes.pdf
ch4_les listes.pdf
 
coursAlgo_V5.pdf
coursAlgo_V5.pdfcoursAlgo_V5.pdf
coursAlgo_V5.pdf
 
Chapitre8: Collections et Enumerations En Java
Chapitre8: Collections et Enumerations En JavaChapitre8: Collections et Enumerations En Java
Chapitre8: Collections et Enumerations En Java
 
Structure des données complexes . pptx .
Structure des données complexes . pptx .Structure des données complexes . pptx .
Structure des données complexes . pptx .
 
Atelier Python 2eme partie par Achraf Kacimi El Hassani
Atelier Python 2eme partie par Achraf Kacimi El HassaniAtelier Python 2eme partie par Achraf Kacimi El Hassani
Atelier Python 2eme partie par Achraf Kacimi El Hassani
 
Cours_Listes .pdf
Cours_Listes .pdfCours_Listes .pdf
Cours_Listes .pdf
 
5- understandinggJava_Collections_v4.pdf
5- understandinggJava_Collections_v4.pdf5- understandinggJava_Collections_v4.pdf
5- understandinggJava_Collections_v4.pdf
 
coursAlgo_V6.ppt
coursAlgo_V6.pptcoursAlgo_V6.ppt
coursAlgo_V6.ppt
 
Programmes et objets informatiques (Prof. Ch. Rapin, Juillet 1989)
Programmes et objets informatiques (Prof. Ch. Rapin, Juillet 1989)Programmes et objets informatiques (Prof. Ch. Rapin, Juillet 1989)
Programmes et objets informatiques (Prof. Ch. Rapin, Juillet 1989)
 
fichiers arborescents
fichiers arborescentsfichiers arborescents
fichiers arborescents
 
Nettoyer et transformer ses données avec Openrefine : partie 2
Nettoyer et transformer ses données avec Openrefine : partie 2Nettoyer et transformer ses données avec Openrefine : partie 2
Nettoyer et transformer ses données avec Openrefine : partie 2
 
Chapitre 2: String en Java
Chapitre 2:  String en JavaChapitre 2:  String en Java
Chapitre 2: String en Java
 
INF220 - Algo DUT SRC1 - Cours 2
INF220 - Algo DUT SRC1 - Cours 2INF220 - Algo DUT SRC1 - Cours 2
INF220 - Algo DUT SRC1 - Cours 2
 
cours TRI selection insertion bublle sort
cours TRI selection insertion bublle sortcours TRI selection insertion bublle sort
cours TRI selection insertion bublle sort
 
Python Listes.pptx
Python Listes.pptxPython Listes.pptx
Python Listes.pptx
 

Plus de Sana Aroussi

Gestion des threads
Gestion des threadsGestion des threads
Gestion des threadsSana Aroussi
 
Chapitre 2 plus court chemin
Chapitre 2 plus court cheminChapitre 2 plus court chemin
Chapitre 2 plus court cheminSana Aroussi
 
Chapitre 1 arbres de recherche
Chapitre 1 arbres de rechercheChapitre 1 arbres de recherche
Chapitre 1 arbres de rechercheSana Aroussi
 
Chapitre 5 arbres binaires
Chapitre 5 arbres binairesChapitre 5 arbres binaires
Chapitre 5 arbres binairesSana Aroussi
 
Chapitre 4 heuristiques et méta heuristiques
Chapitre 4 heuristiques et méta heuristiquesChapitre 4 heuristiques et méta heuristiques
Chapitre 4 heuristiques et méta heuristiquesSana Aroussi
 
Chapitre 3 NP-complétude
Chapitre 3 NP-complétudeChapitre 3 NP-complétude
Chapitre 3 NP-complétudeSana Aroussi
 
Chapitre 2 problème de plus court chemin
Chapitre 2 problème de plus court cheminChapitre 2 problème de plus court chemin
Chapitre 2 problème de plus court cheminSana Aroussi
 
Chapitre 1 arbres de recherche
Chapitre 1 arbres de rechercheChapitre 1 arbres de recherche
Chapitre 1 arbres de rechercheSana Aroussi
 
Chapitre 6 hachage statique
Chapitre 6 hachage statiqueChapitre 6 hachage statique
Chapitre 6 hachage statiqueSana Aroussi
 
Chapitre 5 structures hierarchiques (arbres)
Chapitre 5 structures hierarchiques (arbres)Chapitre 5 structures hierarchiques (arbres)
Chapitre 5 structures hierarchiques (arbres)Sana Aroussi
 
Chapitre iv entrées sorties et bus
Chapitre iv entrées sorties et busChapitre iv entrées sorties et bus
Chapitre iv entrées sorties et busSana Aroussi
 
Chapitre iii interruptions
Chapitre iii interruptionsChapitre iii interruptions
Chapitre iii interruptionsSana Aroussi
 
Chapitre ii mémoires
Chapitre ii mémoiresChapitre ii mémoires
Chapitre ii mémoiresSana Aroussi
 
Chapitre i architectures des processeurs récents
Chapitre i architectures des processeurs récentsChapitre i architectures des processeurs récents
Chapitre i architectures des processeurs récentsSana Aroussi
 
Chapitre vi np complétude
Chapitre vi np complétudeChapitre vi np complétude
Chapitre vi np complétudeSana Aroussi
 
Chapitre v algorithmes gloutons
Chapitre v algorithmes gloutonsChapitre v algorithmes gloutons
Chapitre v algorithmes gloutonsSana Aroussi
 
Chapitre iv algorithmes de tri
Chapitre iv algorithmes de triChapitre iv algorithmes de tri
Chapitre iv algorithmes de triSana Aroussi
 

Plus de Sana Aroussi (20)

Chapitre 1 rappel
Chapitre 1 rappelChapitre 1 rappel
Chapitre 1 rappel
 
Gestion des threads
Gestion des threadsGestion des threads
Gestion des threads
 
Chapitre 2 plus court chemin
Chapitre 2 plus court cheminChapitre 2 plus court chemin
Chapitre 2 plus court chemin
 
Chapitre 1 arbres de recherche
Chapitre 1 arbres de rechercheChapitre 1 arbres de recherche
Chapitre 1 arbres de recherche
 
Chapitre 1 rappel
Chapitre 1 rappelChapitre 1 rappel
Chapitre 1 rappel
 
Chapitre 1 rappel
Chapitre 1 rappelChapitre 1 rappel
Chapitre 1 rappel
 
Chapitre 5 arbres binaires
Chapitre 5 arbres binairesChapitre 5 arbres binaires
Chapitre 5 arbres binaires
 
Chapitre 4 heuristiques et méta heuristiques
Chapitre 4 heuristiques et méta heuristiquesChapitre 4 heuristiques et méta heuristiques
Chapitre 4 heuristiques et méta heuristiques
 
Chapitre 3 NP-complétude
Chapitre 3 NP-complétudeChapitre 3 NP-complétude
Chapitre 3 NP-complétude
 
Chapitre 2 problème de plus court chemin
Chapitre 2 problème de plus court cheminChapitre 2 problème de plus court chemin
Chapitre 2 problème de plus court chemin
 
Chapitre 1 arbres de recherche
Chapitre 1 arbres de rechercheChapitre 1 arbres de recherche
Chapitre 1 arbres de recherche
 
Chapitre 6 hachage statique
Chapitre 6 hachage statiqueChapitre 6 hachage statique
Chapitre 6 hachage statique
 
Chapitre 5 structures hierarchiques (arbres)
Chapitre 5 structures hierarchiques (arbres)Chapitre 5 structures hierarchiques (arbres)
Chapitre 5 structures hierarchiques (arbres)
 
Chapitre iv entrées sorties et bus
Chapitre iv entrées sorties et busChapitre iv entrées sorties et bus
Chapitre iv entrées sorties et bus
 
Chapitre iii interruptions
Chapitre iii interruptionsChapitre iii interruptions
Chapitre iii interruptions
 
Chapitre ii mémoires
Chapitre ii mémoiresChapitre ii mémoires
Chapitre ii mémoires
 
Chapitre i architectures des processeurs récents
Chapitre i architectures des processeurs récentsChapitre i architectures des processeurs récents
Chapitre i architectures des processeurs récents
 
Chapitre vi np complétude
Chapitre vi np complétudeChapitre vi np complétude
Chapitre vi np complétude
 
Chapitre v algorithmes gloutons
Chapitre v algorithmes gloutonsChapitre v algorithmes gloutons
Chapitre v algorithmes gloutons
 
Chapitre iv algorithmes de tri
Chapitre iv algorithmes de triChapitre iv algorithmes de tri
Chapitre iv algorithmes de tri
 

Dernier

Pas de vagues. pptx Film français
Pas de vagues.  pptx      Film   françaisPas de vagues.  pptx      Film   français
Pas de vagues. pptx Film françaisTxaruka
 
Aux origines de la sociologie : du XIXème au début XX ème siècle
Aux origines de la sociologie : du XIXème au début XX ème siècleAux origines de la sociologie : du XIXème au début XX ème siècle
Aux origines de la sociologie : du XIXème au début XX ème siècleAmar LAKEL, PhD
 
Bibdoc 2024 - L’Éducation aux Médias et à l’Information face à l’intelligence...
Bibdoc 2024 - L’Éducation aux Médias et à l’Information face à l’intelligence...Bibdoc 2024 - L’Éducation aux Médias et à l’Information face à l’intelligence...
Bibdoc 2024 - L’Éducation aux Médias et à l’Information face à l’intelligence...Bibdoc 37
 
Calendrier de la semaine du 8 au 12 avril
Calendrier de la semaine du 8 au 12 avrilCalendrier de la semaine du 8 au 12 avril
Calendrier de la semaine du 8 au 12 avrilfrizzole
 
Pas de vagues. pptx Film français
Pas de vagues.  pptx   Film     françaisPas de vagues.  pptx   Film     français
Pas de vagues. pptx Film françaisTxaruka
 
Apprendre avec des top et nano influenceurs
Apprendre avec des top et nano influenceursApprendre avec des top et nano influenceurs
Apprendre avec des top et nano influenceursStagiaireLearningmat
 
DIGNITAS INFINITA - DIGNITÉ HUMAINE; déclaration du dicastère .pptx
DIGNITAS INFINITA - DIGNITÉ HUMAINE; déclaration du dicastère .pptxDIGNITAS INFINITA - DIGNITÉ HUMAINE; déclaration du dicastère .pptx
DIGNITAS INFINITA - DIGNITÉ HUMAINE; déclaration du dicastère .pptxMartin M Flynn
 
Bibdoc 2024 - Sobriete numerique en bibliotheque et centre de documentation.pdf
Bibdoc 2024 - Sobriete numerique en bibliotheque et centre de documentation.pdfBibdoc 2024 - Sobriete numerique en bibliotheque et centre de documentation.pdf
Bibdoc 2024 - Sobriete numerique en bibliotheque et centre de documentation.pdfBibdoc 37
 
PIE-A2-P4-support stagiaires sept 22-validé.pdf
PIE-A2-P4-support stagiaires sept 22-validé.pdfPIE-A2-P4-support stagiaires sept 22-validé.pdf
PIE-A2-P4-support stagiaires sept 22-validé.pdfRiDaHAziz
 
Chana Orloff.pptx Sculptrice franco-ukranienne
Chana Orloff.pptx Sculptrice franco-ukranienneChana Orloff.pptx Sculptrice franco-ukranienne
Chana Orloff.pptx Sculptrice franco-ukranienneTxaruka
 
PIE-A2-P 5- Supports stagiaires.pptx.pdf
PIE-A2-P 5- Supports stagiaires.pptx.pdfPIE-A2-P 5- Supports stagiaires.pptx.pdf
PIE-A2-P 5- Supports stagiaires.pptx.pdfRiDaHAziz
 
Newsletter SPW Agriculture en province du Luxembourg du 10-04-24
Newsletter SPW Agriculture en province du Luxembourg du 10-04-24Newsletter SPW Agriculture en province du Luxembourg du 10-04-24
Newsletter SPW Agriculture en province du Luxembourg du 10-04-24BenotGeorges3
 
La Base unique départementale - Quel bilan, au bout de 5 ans .pdf
La Base unique départementale - Quel bilan, au bout de 5 ans .pdfLa Base unique départementale - Quel bilan, au bout de 5 ans .pdf
La Base unique départementale - Quel bilan, au bout de 5 ans .pdfbdp12
 
Bibdoc 2024 - Les intelligences artificielles en bibliotheque.pdf
Bibdoc 2024 - Les intelligences artificielles en bibliotheque.pdfBibdoc 2024 - Les intelligences artificielles en bibliotheque.pdf
Bibdoc 2024 - Les intelligences artificielles en bibliotheque.pdfBibdoc 37
 
Présentation - Initiatives - CECOSDA - OIF - Fact Checking.pptx
Présentation - Initiatives - CECOSDA - OIF - Fact Checking.pptxPrésentation - Initiatives - CECOSDA - OIF - Fact Checking.pptx
Présentation - Initiatives - CECOSDA - OIF - Fact Checking.pptxJCAC
 
Vulnérabilité numérique d’usage : un enjeu pour l’aide à la réussitepdf
Vulnérabilité numérique d’usage : un enjeu pour l’aide à la réussitepdfVulnérabilité numérique d’usage : un enjeu pour l’aide à la réussitepdf
Vulnérabilité numérique d’usage : un enjeu pour l’aide à la réussitepdfSylvianeBachy
 
Faut-il avoir peur de la technique ? (G. Gay-Para)
Faut-il avoir peur de la technique ? (G. Gay-Para)Faut-il avoir peur de la technique ? (G. Gay-Para)
Faut-il avoir peur de la technique ? (G. Gay-Para)Gabriel Gay-Para
 

Dernier (18)

Pas de vagues. pptx Film français
Pas de vagues.  pptx      Film   françaisPas de vagues.  pptx      Film   français
Pas de vagues. pptx Film français
 
Aux origines de la sociologie : du XIXème au début XX ème siècle
Aux origines de la sociologie : du XIXème au début XX ème siècleAux origines de la sociologie : du XIXème au début XX ème siècle
Aux origines de la sociologie : du XIXème au début XX ème siècle
 
Bibdoc 2024 - L’Éducation aux Médias et à l’Information face à l’intelligence...
Bibdoc 2024 - L’Éducation aux Médias et à l’Information face à l’intelligence...Bibdoc 2024 - L’Éducation aux Médias et à l’Information face à l’intelligence...
Bibdoc 2024 - L’Éducation aux Médias et à l’Information face à l’intelligence...
 
Calendrier de la semaine du 8 au 12 avril
Calendrier de la semaine du 8 au 12 avrilCalendrier de la semaine du 8 au 12 avril
Calendrier de la semaine du 8 au 12 avril
 
Pas de vagues. pptx Film français
Pas de vagues.  pptx   Film     françaisPas de vagues.  pptx   Film     français
Pas de vagues. pptx Film français
 
Apprendre avec des top et nano influenceurs
Apprendre avec des top et nano influenceursApprendre avec des top et nano influenceurs
Apprendre avec des top et nano influenceurs
 
DIGNITAS INFINITA - DIGNITÉ HUMAINE; déclaration du dicastère .pptx
DIGNITAS INFINITA - DIGNITÉ HUMAINE; déclaration du dicastère .pptxDIGNITAS INFINITA - DIGNITÉ HUMAINE; déclaration du dicastère .pptx
DIGNITAS INFINITA - DIGNITÉ HUMAINE; déclaration du dicastère .pptx
 
Bibdoc 2024 - Sobriete numerique en bibliotheque et centre de documentation.pdf
Bibdoc 2024 - Sobriete numerique en bibliotheque et centre de documentation.pdfBibdoc 2024 - Sobriete numerique en bibliotheque et centre de documentation.pdf
Bibdoc 2024 - Sobriete numerique en bibliotheque et centre de documentation.pdf
 
PIE-A2-P4-support stagiaires sept 22-validé.pdf
PIE-A2-P4-support stagiaires sept 22-validé.pdfPIE-A2-P4-support stagiaires sept 22-validé.pdf
PIE-A2-P4-support stagiaires sept 22-validé.pdf
 
Chana Orloff.pptx Sculptrice franco-ukranienne
Chana Orloff.pptx Sculptrice franco-ukranienneChana Orloff.pptx Sculptrice franco-ukranienne
Chana Orloff.pptx Sculptrice franco-ukranienne
 
PIE-A2-P 5- Supports stagiaires.pptx.pdf
PIE-A2-P 5- Supports stagiaires.pptx.pdfPIE-A2-P 5- Supports stagiaires.pptx.pdf
PIE-A2-P 5- Supports stagiaires.pptx.pdf
 
Newsletter SPW Agriculture en province du Luxembourg du 10-04-24
Newsletter SPW Agriculture en province du Luxembourg du 10-04-24Newsletter SPW Agriculture en province du Luxembourg du 10-04-24
Newsletter SPW Agriculture en province du Luxembourg du 10-04-24
 
La Base unique départementale - Quel bilan, au bout de 5 ans .pdf
La Base unique départementale - Quel bilan, au bout de 5 ans .pdfLa Base unique départementale - Quel bilan, au bout de 5 ans .pdf
La Base unique départementale - Quel bilan, au bout de 5 ans .pdf
 
Bibdoc 2024 - Les intelligences artificielles en bibliotheque.pdf
Bibdoc 2024 - Les intelligences artificielles en bibliotheque.pdfBibdoc 2024 - Les intelligences artificielles en bibliotheque.pdf
Bibdoc 2024 - Les intelligences artificielles en bibliotheque.pdf
 
Présentation - Initiatives - CECOSDA - OIF - Fact Checking.pptx
Présentation - Initiatives - CECOSDA - OIF - Fact Checking.pptxPrésentation - Initiatives - CECOSDA - OIF - Fact Checking.pptx
Présentation - Initiatives - CECOSDA - OIF - Fact Checking.pptx
 
Vulnérabilité numérique d’usage : un enjeu pour l’aide à la réussitepdf
Vulnérabilité numérique d’usage : un enjeu pour l’aide à la réussitepdfVulnérabilité numérique d’usage : un enjeu pour l’aide à la réussitepdf
Vulnérabilité numérique d’usage : un enjeu pour l’aide à la réussitepdf
 
Bulletin des bibliotheques Burkina Faso mars 2024
Bulletin des bibliotheques Burkina Faso mars 2024Bulletin des bibliotheques Burkina Faso mars 2024
Bulletin des bibliotheques Burkina Faso mars 2024
 
Faut-il avoir peur de la technique ? (G. Gay-Para)
Faut-il avoir peur de la technique ? (G. Gay-Para)Faut-il avoir peur de la technique ? (G. Gay-Para)
Faut-il avoir peur de la technique ? (G. Gay-Para)
 

Chapitre 3 structures séquentielles

  • 1. 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/
  • 2. PLAN DU CHAPITRE III I. Introduction II. Listes Linéaires Chaînées (LLC) III. Files d’Attente (FIFO) IV. Piles (LIFO) 2
  • 3. 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
  • 4. PARTIE I: LISTES LINÉAIRES CHAÎNÉES (LLC)
  • 5. 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. 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
  • 7. 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
  • 8. 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. 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. 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. 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. 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. ALGORITHMES SUR LES LLCS
  • 13. 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. ALGORITHMES SUR LES LLCS
  • 14. 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. ALGORITHMES SUR LES LLCS
  • 15. 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. ALGORITHMES SUR LES LLCS
  • 16. 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 ALGORITHMES SUR LES LLCS
  • 17. 17 Soient la liste suivante: La liste imprimée est 2, 10, 5, -1 et 6 ALGORITHMES SUR LES LLCS 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. 18 Soient la liste suivante: La longueur de cette liste = 5 ALGORITHMES SUR LES LLCS LONGUEUR 2 10 5 -1 6 L Fonction LongLLC (L:*maillon): entier Début P L; Cpt 0; Tant que (P≠nil) faire // la liste n’est pas vide DTQ Cpt ++ P ←suivant (P) FTQ Retourner (Cpt) Fin
  • 19. 19 Rechercher une valeur « v=5 » dans la liste suivante: Si v= 1 alors la fonction retourne nil. ALGORITHMES SUR LES LLCS RECHERCHE 2 10 5 -1 6 L Fonction RechLLC (L:*maillon, v:entier): *maillon Début P ←L Tant que (P≠nil) faire // la liste n’est pas vide DTQ Si valeur (P) = v alors retourner (P) Sinon P ←suivant (P) FTQ Retourner (nil) Fin P
  • 20. 20 Rechercher le maillon qui se trouve à la position k = 4 Si k= 6, le maillon n’existe même pas (P = nil) ALGORITHMES SUR LES LLCS 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. 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 ALGORITHMES SUR LES LLCS INSERTION
  • 22. 22 Cas 1: Insertion au début ALGORITHMES SUR LES LLCS 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. 23 Cas 2: Insertion à la fin. ALGORITHMES SUR LES LLCS 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. 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; ALGORITHMES SUR LES LLCS INSERTION 2 10 5 -1 6 L Q P (1) aff_suiv (P, suivant (Q)) k (2) aff_suiv (Q, P)
  • 25. 25 ALGORITHMES SUR LES LLCS 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. 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 ALGORITHMES SUR LES LLCS CRÉATION val suiv ??? ??? val suiv 2 NIL
  • 27. 27 Cas 1: Insertion à la fin. Soient N= 5 et les valeurs suivantes: 2, 10, 5, -1, 6 ALGORITHMES SUR LES LLCS 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) Si (L=nil) alors //la liste est vide L ←P // mettre à jour l’entête Sinon aff_suiv(Q, P) Q←P //sauvegarder l’@ du dernier maillon FP Fin Procédure CreerLLC (L:*maillon) Début Pour i←1 à N faire DP lire (v) InsererLLC_Fin(L, v) FP Fin
  • 28. 28 Soient N= 5 et les valeurs suivantes: 2, 10, 5, -1, 6 Cas 2: Insertion au début ALGORITHMES SUR LES LLCS CRÉATION -1 5 10 2 6 L P aff_suiv (P, L) Procédure CreerLLC_inverse (L:*maillon) Début Pour 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 FP Fin Procédure CreerLLC_inversé (L:*maillon) Début Pour i←1 à N faire lire (v) InsérerLLC_Deb( L, v) Fin
  • 29. 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. ALGORITHMES SUR LES LLCS SUPPRESSION
  • 30. 30 Exemple 1: Suppression v = 5 Exemple 2 : Suppression v = 2 ALGORITHMES SUR LES LLCS SUPPRESSION 2 10 5 -1 6 L 2 10 5 -1 6 PL 2 10 5 -1 L Q P 6 Q
  • 31. 31 ALGORITHMES SUR LES LLCS 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. 32 Suppression de tous les maillons contenant la valeur v ALGORITHMES SUR LES LLCS 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. 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; ALGORITHMES SUR LES LLCS SUPPRESSION 2 10 5 -1 L Q k P
  • 34. 34 Suppression à une position donné « k ». ALGORITHMES SUR LES LLCS 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. 35 Soient la liste suivante: ALGORITHMES SUR LES LLCS 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. 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. 37 Impression d’une LLC circulaire LISTES PARTICULIÈRES 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. 38 Recherche le premier maillon contenant la valeur v LISTES PARTICULIÈRES LISTE CIRCULAIRE (QUELQUES ALGORITHMES) 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. 39 Insertion dans une LLC circulaire LISTES PARTICULIÈRES LISTE CIRCULAIRE (QUELQUES ALGORITHMES) 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 vide aff_suiv(P, P) L ←P // mettre à jour l’entête Sinon aff_suiv(P , suivant (L)) aff_suiv (L, P) Fin P Q
  • 40. 40 Construction d’une LLC circulaire Construire une LLC unidirectionnel À la fin, chaîner le dernier maillon avec le premier LISTES PARTICULIÈRES LISTE CIRCULAIRE (QUELQUES ALGORITHMES) 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ête Sinon aff_suiv(Q, P) Q←P //sauvegarder l’@ du dernier maillon aff_suiv (P, L); Fin Q P
  • 41. 41 Construction d’une LLC circulaire LISTES PARTICULIÈRES LISTE CIRCULAIRE (QUELQUES ALGORITHMES) 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 L ←P // mettre à jour l’entête Sinon aff_suiv(Q, P) aff_suiv(P, L)// lier le dernier maillon au premier Q←P //sauvegarder l’@ du dernier maillon Fin Q P
  • 42. 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 LISTES PARTICULIÈRES LISTE CIRCULAIRE (QUELQUES ALGORITHMES) 2 10 5 -1L
  • 43. 43 Suppression du maillon contenant la valeur v 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. 44 Destruction d’une LLC circulaire LISTES PARTICULIÈRES LISTE CIRCULAIRE (QUELQUES ALGORITHMES) 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. 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. LISTES PARTICULIÈRES LISTE BIDIRECTIONNELLE Tête Nil V1 V2 V3 V4 V5 Nil Queue val suiv prec
  • 46. 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. LISTES PARTICULIÈRES LISTE BIDIRECTIONNELLE 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
  • 47. Le modèle des LLC bidirectionnelles est donc étendu par les opérations suivantes : MLLCbd = MLLC + { Init, Aff_prec, Précédent } LISTES PARTICULIÈRES LISTE BIDIRECTIONNELLE 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. 48 Impression d’une LLC Bidirectionnelle LISTES PARTICULIÈRES 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. 49 Recherche d’une valeur dans une LLC Bidirectionnelle LISTES PARTICULIÈRES LISTE BIDIRECTIONNELLE (QUELQUES ALGORITHMES) Fonction RechLLCbd(L: ListeBD, v:entier): *MaillonBD Début P ←L.Tete Tant 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): *MaillonBD Début P ←L.Queue Tant 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. 50 Recherche du maillon qui se trouve à une position donnée LISTES PARTICULIÈRES LISTE BIDIRECTIONNELLE (QUELQUES ALGORITHMES) 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. 51 Insertion au début de la liste LISTES PARTICULIÈRES LISTE BIDIRECTIONNELLE (QUELQUES ALGORITHMES) 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. 52 Insertion à la fin de la liste. LISTES PARTICULIÈRES LISTE BIDIRECTIONNELLE (QUELQUES ALGORITHMES) 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. 53 Insertion à une position donnée LISTES PARTICULIÈRES LISTE BIDIRECTIONNELLE (QUELQUES ALGORITHMES) 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 Allouer (P); aff_val(P, v); aff_suiv (Precedent (S), P) ; aff_prec (P, Precedent (S)); aff_suiv (P, S) ;aff_prec (S, P) ;
  • 54. 54 Construction d’une LLC Bidirectionnelle Soient N= 4 et les valeurs suivantes: 2, 5, -1, 6 LISTES PARTICULIÈRES LISTE BIDIRECTIONNELLE (QUELQUES ALGORITHMES) 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. 55 Construction d’une LLC Bidirectionnelle Soient N= 4 et les valeurs suivantes: 2, 5, -1, 6 LISTES PARTICULIÈRES LISTE BIDIRECTIONNELLE (QUELQUES ALGORITHMES) 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. 56 Suppression du maillon contenant la valeur v LISTES PARTICULIÈRES LISTE BIDIRECTIONNELLE (QUELQUES ALGORITHMES) 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. 57 Destruction d’une LLC Bidirectionnelle LISTES PARTICULIÈRES LISTE BIDIRECTIONNELLE (QUELQUES ALGORITHMES) 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. 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 LISTES PARTICULIÈRES LISTE BIDIRECTIONNELLE CIRCULAIRE Tête V1 V2 V3 V4 V5
  • 59. 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. 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 REPRÉSENTATION CONTIGÜE DÉFINITION
  • 61. 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] REPRÉSENTATION CONTIGÜE MODÈLE
  • 62. 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) REPRÉSENTATION CONTIGÜE MODÈLE
  • 63. Faut-il utiliser un tableau ou une LLC? CONCLUSION 63
  • 64. 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. 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
  • 67. 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. 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. 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. 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. 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. 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. 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. 74 IMPLÉMENTATION STATIQUE PAR DÉCALAGE Définition de la structure : 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. 75 IMPLÉMENTATION STATIQUE PAR DÉCALAGE 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. 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. 77 IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE 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. 78 IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE 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. 79 IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE Définition de la structure : TYPE File_Attente = STRUCTURE Elements : TABLEAU[Max] de Typeqq Tête, Queue : ENTIER FIN VAR F : File_Attente File_Attente Eléments V2 V3 V4 V5 Tête = 1 Queue = 5
  • 80. 80 IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE Modèle Implémentation 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 Defiler(F,X) SI (NON Filevide(F)) F.Tete ← (F.Tete + 1)Mod Max X ← F.elements[F.Tete]
  • 81. 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. 82 IMPLÉMENTATION DYNAMIQUE V0 V1 V2 V3 V4 Tête Queue Définition de la structure : TYPE Maillon = STRUCTURE val : typeqq suiv: * Maillon FIN TYPE File_Attente = STRUCTURE Tête, Queue : *Maillon FIN VAR F: File_Attente File_Attente
  • 83. 83 IMPLÉMENTATION DYNAMIQUE Modèle Implémentation 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 Defiler(F,X) SI (NON Filevide(F)) P ← F.Tete X ← Valeur(F.Tete) F.Tete ← Suivant(F.Tete) Liberer(P)
  • 84. 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. 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). FILE D’ATTENTE AVEC PRIORITÉ
  • 86. 86 FILE D’ATTENTE AVEC PRIORITÉ IMPLÉMENTATION STATIQUE PAR DÉCALAGE Définition de la structure : TYPE prog = STRUCTURE prio : ENTIER PSW : typeqcq FIN TYPE File_Attente = STRUCTURE Elements : TABLEAU[Max] de prog Queue : ENTIER FIN (3, PSW) (2, PSW) (1, PSW) (1, PSW) (0, PSW) Queue
  • 87. 87 FILE D’ATTENTE AVEC PRIORITÉ IMPLÉMENTATION STATIQUE PAR DÉCALAGE Modèle Implémentation Initfile(F) F.Queue ←-1 Filevide(F) Retourner (F.Queue = -1) Filepleine(F) Retourner (F.Queue = Max-1) 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
  • 88. 88 FILE D’ATTENTE AVEC PRIORITÉ IMPLÉMENTATION STATIQUE PAR DÉCALAGE (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. 89 FILE D’ATTENTE AVEC PRIORITÉ IMPLÉMENTATION STATIQUE PAR DÉCALAGE 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. 90 FILE D’ATTENTE AVEC PRIORITÉ IMPLÉMENTATION STATIQUE PAR DÉCALAGE 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 F.Queue ← F.Queue + 1
  • 91. 91 FILE D’ATTENTE AVEC PRIORITÉ IMPLÉMENTATION STATIQUE PAR DÉCALAGE 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é ) faire F.Elements[I+1] ← F.Elements[I] I←I-1 //insérer le programme X F.Elements[I] ← X //mettre à jour la queue F.Queue ← F.Queue + 1
  • 92. 92 FILE D’ATTENTE AVEC PRIORITÉ IMPLÉMENTATION STATIQUE PAR DÉCALAGE 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 -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. 93 FILE D’ATTENTE AVEC PRIORITÉ IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE Définition de la structure : TYPE prog = STRUCTURE prio : ENTIER PSW : typeqcq FIN TYPE File_Attente = STRUCTURE Elements : TABLEAU[Max] de prog Queue, Tete : ENTIER FIN (3, PSW) (2, PSW) (1, PSW) (1, PSW) (0, PSW) TeteQueue
  • 94. 94 FILE D’ATTENTE AVEC PRIORITÉ IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE Modèle Implémentation 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. 95 FILE D’ATTENTE AVEC PRIORITÉ IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE (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 Tete Tete
  • 96. 96 FILE D’ATTENTE AVEC PRIORITÉ IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE (1, PSW) (0, PSW) (3, PSW) (2, PSW) (1, PSW) Queue Enfiler (F, (2, PSW)) Tete (1, PSW) (1, PSW) (0, PSW) (3, PSW) (2, PSW) (2, PSW) Queue Tete
  • 97. 97 FILE D’ATTENTE AVEC PRIORITÉ IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE 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. 98 FILE D’ATTENTE AVEC PRIORITÉ IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE 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. 99 FILE D’ATTENTE AVEC PRIORITÉ IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE 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.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. 100 FILE D’ATTENTE AVEC PRIORITÉ IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE 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) Décrémentation des indices!! 4ème méthode: insérer le nouvel élément à la tête ensuite essayer de trier le tableau en faisant des permutations (principe de tri par insertion)
  • 101. 101 FILE D’ATTENTE AVEC PRIORITÉ IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE (2, PSW) (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 Tete Tete
  • 102. 102 FILE D’ATTENTE AVEC PRIORITÉ IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE (2, PSW) (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 Tete Tete
  • 103. 103 FILE D’ATTENTE AVEC PRIORITÉ IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE (3, PSW) (2, PSW) (1, PSW) (1, PSW) (0, PSW) (2, PSW) Queue Enfiler (F, (2, PSW)) (2, PSW) (2, PSW) (1, PSW) (1, PSW) (0, PSW) (3, PSW) Queue Tete Tete
  • 104. 104 FILE D’ATTENTE AVEC PRIORITÉ IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE (1, PSW) (0, PSW) (2, PSW) (3, PSW) (2, PSW) (1, PSW) Queue Enfiler (F, (2, PSW)) Tete (1, PSW) (0, PSW) (3, PSW) (2, PSW) (2, PSW) (1, PSW) Queue Tete
  • 105. 105 FILE D’ATTENTE AVEC PRIORITÉ IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE 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..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. 106 FILE D’ATTENTE AVEC PRIORITÉ IMPLÉMENTATION DYNAMIQUE (3,PSW) Tête Queue (2,PSW) (1,PSW) (1,PSW) (0,PSW) Définition de la structure : TYPE prog = STRUCTURE prio : ENTIER PSW : typeqcq FIN TYPE Maillon = STRUCTURE val : prog suiv: * Maillon FIN TYPE File_Attente = STRUCTURE TêTe, Queue : *Maillon FIN
  • 107. 107 FILE D’ATTENTE AVEC PRIORITÉ IMPLÉMENTATION DYNAMIQUE Modèle Implémentation Initfile(F) F.Tete ← NIL F.Queue← NIL Filevide(F) Retourner (F.Tete = NIL ) Defiler(F,X) SI (NON Filevide(F)) P ← F.Tete X ← Valeur(F.Tete) F.Tete ← Suivant(F.Tete) Liberer(P)
  • 108. 108 FILE D’ATTENTE AVEC PRIORITÉ IMPLÉMENTATION DYNAMIQUE Enfiler (F, (2, PSW)) (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. 109 FILE D’ATTENTE AVEC PRIORITÉ 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)
  • 111. PLAN DE LA PARTIE III Définition Modèle Implémentation Représentation statique Représentation dynamique Utilisation 111
  • 112. 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. 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. 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. 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. 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. 117 IMPLÉMENTATION STATIQUE PAR DÉCALAGE Définition de la structure : TYPE Pile= STRUCTURE Elements : TABLEAU[Max] de Typeqq Sommet : ENTIER FIN VAR P : Pile Pile Eléments Sommet =5 V5 V4 V3 V2 V1 V0 0 max-1
  • 118. 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. 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 IMPLÉMENTATION DYNAMIQUE V4 V3 V2 V1 V0 Sommet (Tête) Empilement Dépilement
  • 120. 120 IMPLÉMENTATION DYNAMIQUE V4 V3 V2 V0 V1 Sommet Définition de la structure : TYPE Maillon = STRUCTURE val : typeqq suiv: * Maillon FIN VAR sommet: *Maillon Pile
  • 121. 121 IMPLÉMENTATION DYNAMIQUE Modèle Implémentation 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. 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. 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. 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. 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* EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
  • 126. 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 EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
  • 127. 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). EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE) [‘7’, 0]
  • 128. 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+* EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
  • 129. 129 3. Ecrire l’algorithme qui permet de transformer une expression infixée en une expression postfixée. Exemples illustratif: EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE) 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. 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] EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
  • 131. 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] EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
  • 132. 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 EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
  • 133. 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 EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
  • 134. 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 EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
  • 135. 135 Transformation infixée postfixée (Déclaration): EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE) Type Terme = structure Op : Chaines de caractères; 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 1 Opérateur binaire (+, -) 2 Opérateur binaire ( *, /, %) 3 Opérateur unaire ( - unaire) 4 Parenthèse ouvrante ou fermante
  • 136. 136 Transformation infixée postfixée (Algorithme): EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE) 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. 137 Transformation infixée postfixée (Algorithme): EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE) 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. 138 3. Donner l’algorithme d’évaluation d’une expression postfixée. Exemples illustratif: EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE) 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. 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 EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
  • 140. 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) -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 » EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE) Exemple 2: 3~2+56*2/-3+ = -13
  • 141. 141 1. empiler(1) 2. empiler(3) 3. empiler(4) 4. depiler (4); depiler (3); empiler( 3 * 4) 5. depiler (12); depiler (1); empiler(1+12) 6. empiler(2) 7. depiler (2); depiler (13); empiler(13+2) 8. empiler(5) 9. depiler (5); depiler (15); empiler(15*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 EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE) Exemple 3: 134*+2+5* = 75
  • 142. 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 EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
  • 143. 14 3 Evaluation d'une expression postfixée (Déclaration) EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE) Type Terme = structure Op : Chaines de caractères; 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 1 Opérateur binaire (+, -) 2 Opérateur binaire ( *, /, %) 3 Opérateur unaire ( - unaire) 4 Parenthèse ouvrante ou fermante
  • 144. 144 Evaluation d'une expression postfixée (Fonction Calcul) EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE) 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
  • 145. Evaluation d'une expression postfixée (Algorithme) EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE) 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
  • 146. 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