CHAPITRE III:
STRUCTURES SÉQUENTIELLES
Université Saad Dahlab – Blida1
Faculté des Sciences
Département d’Informatique
Lic...
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 ac...
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 conti...
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 ...
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 sauvegar...
Nil
8
DÉFINITIONS
Tête de liste
…….
val suiv
V1 @1 V2 @2 V3 @3 Vn @n
Langage
Algorithmique
Langage C
type Maillon = Struct...
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ér...
10
Voici l’équivalence en langage C, des fonctions et des procédures du
modèle :
MODÈLE DE LLC (MLLC)
Modules Implémentati...
11
Parcours :
Accès par valeur : il s'agit de rechercher (séquentiellement à
partir de la tête) une valeur v dans la liste...
12
Mises à jour :
Construction d'une liste à partir de n valeurs données.
Insertion d'une valeur (v) à une position donnée...
13
Mises à jour :
Suppression du maillon se trouvant à une position donnée :
rechercher par position le maillon et le libé...
14
Tri sur les LLC : Les mêmes algorithmes de tri utilisable pour
les tableaux, en prenant en compte que l'accès par posit...
15
Exercice 1: Soient L une liste d’entier non ordonnée.
Développer les modules suivants:
a. Imprimer la liste
b. Calculer...
16
Exercice 1 (suite): Soient L une liste d’entier non
ordonnée. Développer les modules suivants:
h) Supprimer une valeur ...
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
Pro...
18
Soient la liste suivante:
La longueur de cette liste = 5
ALGORITHMES SUR LES LLCS
LONGUEUR
2 10 5 -1 6
L
Fonction LongL...
19
Rechercher une valeur « v=5 » dans la liste suivante:
Si v= 1 alors
la fonction retourne nil.
ALGORITHMES SUR LES LLCS
...
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...
21
Pour ajouter un élément dans la liste, il y a plusieurs
situations :
1. Insertion au début de la liste
2. Insertion à l...
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:...
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_Fi...
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 maill...
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...
26
Pour créer une liste:
1. Allouer un nouveau maillon
2. Initialiser le maillon avec la valeur lue
3. Insérer dans la lis...
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...
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 ...
29
Pour supprimer un maillon contenant la valeur v, il faut
d’abord rechercher ce maillon. Une fois trouvé (soit P ce
mail...
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...
31
ALGORITHMES SUR LES LLCS
SUPPRESSION
Procédure SupprimerLLC (L:*maillon, v:entier)
Début
P←L; Q nil
TQ ((P ≠ nil) et (v...
32
Suppression de tous les maillons contenant la valeur v
ALGORITHMES SUR LES LLCS
SUPPRESSION
Procédure SupprimerLLC_tous...
33
Suppression à une position donnée « k ».
Deux situations se présentent:
k = 1, supprimer le premier maillon
k ≠ 1, accé...
34
Suppression à une position donné « k ».
ALGORITHMES SUR LES LLCS
SUPPRESSION
Procédure Supprimer_pos (L:*maillon, k:ent...
35
Soient la liste suivante:
ALGORITHMES SUR LES LLCS
DESTRUCTION
2 10 5 -1 6
L
Procédure DetruireLLC (L:*maillon)
Début
T...
36
Liste circulaire est une LLC où le dernier maillon
pointe le premier, formant ainsi un cercle.
La tête de la liste est ...
37
Impression d’une LLC circulaire
LISTES PARTICULIÈRES
LISTE CIRCULAIRE (QUELQUES ALGORITHMES)
2 10 5 -1L
Procédure Impri...
38
Recherche le premier maillon contenant la valeur v
LISTES PARTICULIÈRES
LISTE CIRCULAIRE (QUELQUES ALGORITHMES)
2 10 5 ...
39
Insertion dans une LLC circulaire
LISTES PARTICULIÈRES
LISTE CIRCULAIRE (QUELQUES ALGORITHMES)
2 10 5 -1
6
L
Procédure ...
40
Construction d’une LLC circulaire
Construire une LLC unidirectionnel
À la fin, chaîner le dernier maillon avec le premi...
41
Construction d’une LLC circulaire
LISTES PARTICULIÈRES
LISTE CIRCULAIRE (QUELQUES ALGORITHMES)
2 10 5 -1 6L
2 éme Métho...
42
Suppression du maillon contenant la valeur v
Rechercher le maillon contenant la valeur v
S’il existe un tel maillon, on...
43
Suppression du maillon contenant la valeur v
LISTES PARTICULIÈRES LISTE CIRCULAIRE
(QUELQUES ALGORITHMES)
Procédure Sup...
44
Destruction d’une LLC circulaire
LISTES PARTICULIÈRES
LISTE CIRCULAIRE (QUELQUES ALGORITHMES)
2 10 5 -1L
Procédure Detr...
45
Liste bidirectionnelle ou Liste Doublement
Chaînées est une liste que l'on peut parcourir dans les
deux sens : de gauch...
Chaque maillon d’une liste bidirectionnelle comporte trois champs:
Un champ contenant la donnée.
Un pointeur vers l'élémen...
Le modèle des LLC bidirectionnelles est donc étendu par les
opérations suivantes :
MLLCbd = MLLC + { Init, Aff_prec, Précé...
48
Impression d’une LLC Bidirectionnelle
LISTES PARTICULIÈRES
LISTE BIDIRECTIONNELLE (QUELQUES ALGORITHMES)
Tete
2 5 -1 6
...
49
Recherche d’une valeur dans une LLC Bidirectionnelle
LISTES PARTICULIÈRES
LISTE BIDIRECTIONNELLE (QUELQUES ALGORITHMES)...
50
Recherche du maillon qui se trouve à une position donnée
LISTES PARTICULIÈRES
LISTE BIDIRECTIONNELLE (QUELQUES ALGORITH...
51
Insertion au début de la liste
LISTES PARTICULIÈRES
LISTE BIDIRECTIONNELLE (QUELQUES ALGORITHMES)
Aff_suiv (P, Tete)
Te...
52
Insertion à la fin de la liste.
LISTES PARTICULIÈRES
LISTE BIDIRECTIONNELLE (QUELQUES ALGORITHMES)
Procédure InsererLLC...
53
Insertion à une position donnée
LISTES PARTICULIÈRES
LISTE BIDIRECTIONNELLE (QUELQUES ALGORITHMES)
P
K
Tete
2 5 -1 6
Qu...
54
Construction d’une LLC Bidirectionnelle
Soient N= 4 et les valeurs suivantes: 2, 5, -1, 6
LISTES PARTICULIÈRES
LISTE BI...
55
Construction d’une LLC Bidirectionnelle
Soient N= 4 et les valeurs suivantes: 2, 5, -1, 6
LISTES PARTICULIÈRES
LISTE BI...
56
Suppression du maillon contenant la valeur v
LISTES PARTICULIÈRES
LISTE BIDIRECTIONNELLE (QUELQUES ALGORITHMES)
2 5 -1 ...
57
Destruction d’une LLC Bidirectionnelle
LISTES PARTICULIÈRES
LISTE BIDIRECTIONNELLE (QUELQUES ALGORITHMES)
Tete
2 5 -1 6...
58
Liste bidirectionnelle circulaire est une LLC à double
sens et dont le dernier maillon pointe sur le premier
maillon et...
59
On peut représenter une LLC par un tableau où chaque
élément contient au moins 3 champs : l'information,
l’indice du su...
60
Initialement, le champ Vide de tous les éléments sont à
vrai pour indiquer que les cases sont disponibles.
Une LLC est ...
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 ca...
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...
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 ...
65
Tableau non ordonné LLC unidirectionnelle non
ordonné
Sur-
encombrement
Non:
La relation suivant étant
implicite, il n’...
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’...
68
Une file (en anglais queue) est une structure de données
basée sur le principe « premier arrivé, premier sorti » (en
an...
69
Une file d'attente peut être définie comme une collection
d'éléments dans laquelle tout nouvel élément est inséré
(ajou...
70
Les files d’attente sont utilisées, en programmation
comme des buffers (mémoire tampon = espace de
mémorisation tempora...
71
Les opérations habituelles sur les files sont :
Initialisation de la file
Vérification du contenu de la file (vide ou p...
72
Les files d’attente peuvent être présentées en deux
manières:
statique en utilisant les tableaux,
dynamique en utilisan...
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.
IM...
74
IMPLÉMENTATION STATIQUE PAR DÉCALAGE
Définition de la structure :
TYPE File_Attente = STRUCTURE
Elements : TABLEAU[Max]...
75
IMPLÉMENTATION STATIQUE PAR DÉCALAGE
Modèle Implémentation
Initfile(F) F.Queue ←-1
Filevide(F) Retourner (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 ←←←← (qu...
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 = ...
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 ...
79
IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE
Définition de la structure :
TYPE File_Attente = STRUCTURE
Elements : TA...
80
IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE
Modèle Implémentation
Initfile(F) F.Tête ←Max; F.Queue ←Max
Filevide(F) ...
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...
82
IMPLÉMENTATION DYNAMIQUE
V0 V1 V2 V3 V4
Tête Queue
Définition de la structure :
TYPE Maillon = STRUCTURE
val : typeqq
s...
83
IMPLÉMENTATION DYNAMIQUE
Modèle Implémentation
Initfile(F) F.Tete ← NIL; F.Queue← NIL
Filevide(F) Retourner (F.Tete = N...
84
Une file d’attente avec priorité est une collection
d’éléments dans laquelle l’insertion ne se fait pas toujours
à la q...
85
Exercice 6:
Le processeur possède un buffer permettant de gérer ses programmes
à exécuter. Ce buffer est une file d'att...
86
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR DÉCALAGE
Définition de la structure :
TYPE prog = STRUCTURE
pr...
87
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR DÉCALAGE
Modèle Implémentation
Initfile(F) F.Queue ←-1
Filevid...
88
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR DÉCALAGE
(3,
PSW)
(2,
PSW)
(1,
PSW)
(1,
PSW)
(0,
PSW)
Queue
En...
89
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR DÉCALAGE
Enfilement:
1ère méthode: rechercher la bonne positio...
90
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR DÉCALAGE
1ère méthode: Enfiler(F,X)
SI (NON Filepleine(F))
I ←...
91
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR DÉCALAGE
2ère méthode: Enfiler(F,X)
SI (NON Filepleine(F))
I ←...
92
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR DÉCALAGE
3ème méthode: Enfiler(F,X)
SI (NON Filepleine(F))
//m...
93
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE
Définition de la structure :
TYPE prog = ST...
94
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE
Modèle Implémentation
Initfile(F) F.Tête ←M...
95
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE
(3,
PSW)
(2,
PSW)
(1,
PSW)
(1,
PSW)
(0,
PSW...
96
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE
(1,
PSW)
(0,
PSW)
(3,
PSW)
(2,
PSW)
(1,
PSW...
97
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE
Enfilement:
1ère méthode: rechercher la bon...
98
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE
Enfilement:
3ème méthode: insérer le nouvel...
99
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE
3ème Méthode: Enfiler(F,X)
SI (NON Fileplei...
100
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE
Enfilement:
3ème méthode: insérer le nouve...
101
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE
(2,
PSW)
(3,
PSW)
(2,
PSW)
(1,
PSW)
(1,
PS...
102
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE
(2,
PSW)
(3,
PSW)
(2,
PSW)
(1,
PSW)
(1,
PS...
103
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE
(3,
PSW)
(2,
PSW)
(1,
PSW)
(1,
PSW)
(0,
PS...
104
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE
(1,
PSW)
(0,
PSW)
(2,
PSW)
(3,
PSW)
(2,
PS...
105
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE
4ème Méthode: Enfiler (F, X)
SI (NON Filep...
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...
107
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION DYNAMIQUE
Modèle Implémentation
Initfile(F) F.Tete ← NIL
F.Queue← NIL
File...
108
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION DYNAMIQUE
Enfiler (F, (2, PSW))
(3,PSW)
Tête Queue
(2,PSW) (1,PSW) (1,PSW)...
109
FILE D’ATTENTE AVEC PRIORITÉ
IMPLÉMENTATION DYNAMIQUEEnfiler(F,X)
Allouer (P), Aff_Val(P, X), aff_suiv(P, NIL)
Si (Fil...
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
...
113
Une pile peut être définie comme une collection
d'éléments dans laquelle tout nouvel élément est inséré à
la fin (empi...
114
Les opérations habituelles sur les piles sont :
Initialisation de la pile
Vérification du contenu de la pile (vide ou ...
115
Les piles peuvent être présentées en deux manières:
statique en utilisant les tableaux,
dynamique en utilisant les lis...
116
L’implémentation statique des piles utilise les tableaux.
Dans ce cas, la capacité de la pile est limitée par la taill...
117
IMPLÉMENTATION STATIQUE PAR DÉCALAGE
Définition de la structure :
TYPE Pile= STRUCTURE
Elements : TABLEAU[Max] de Type...
118
IMPLÉMENTATION STATIQUE
modèle Implémentation
Initpile(P) P.Sommet ← -1
Pilevide(P) Retourner ( P.Sommet = -1)
Pileple...
119
L’implémentation dynamique utilise les listes linéaires
chinées. Dans ce cas, la pile peut être vide, mais ne peut êtr...
120
IMPLÉMENTATION DYNAMIQUE
V4 V3 V2 V0 V1
Sommet
Définition de la structure :
TYPE Maillon = STRUCTURE
val : typeqq
suiv...
121
IMPLÉMENTATION DYNAMIQUE
Modèle Implémentation
Initpile(Sommet) Sommet ← Nil
Pilevide(Sommet) Retourner (Sommet = Nil)...
122
Analyse syntaxique : qui est une phase de la
compilation qui nécessite une pile.
Par exemple, le problème de la reconn...
123
Calcul arithmétique : Une application courante des
piles se fait dans le calcul arithmétique: l'ordre dans la
pile per...
124
EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
Il est demandé de réaliser une calculette qui prend en ent...
125
1. Ecrire les expressions suivantes en postfixée:
2. Une expression arithmétique peut être implémentée
sous forme d’un...
1262. Donner la LLC qui présente cette expression
5 * (((9+8)*(4*6))+7) en format infixé et postfixé.
Type Terme = structu...
127
[‘5’, 0] [‘*’, 2] [‘(’, 4] [‘(’, 4] [‘(’, 4]
[‘9’, 0][‘+’, 2][‘8’, 0][‘)’, 4]
[‘(’, 4] [‘4’, 0] [‘*’, 2] [‘6’, 0]
[‘)’...
128
[‘5’, 0] [‘9’, 0] [‘8’, 0] [‘*’, 2] [‘4’, 0]
[‘6’, 0][‘*’, 2][‘*’, 2][‘7’, 0]
[‘*’, 2]
[‘+’, 1]
Lpostfixe
La LLC qui p...
129
3. Ecrire l’algorithme qui permet de transformer une
expression infixée en une expression postfixée.
Exemples illustra...
130
1. Inserer ([5, 0])
2. Empiler ([*, 2])
3. Empiler ([(, 4])
4. Empiler ([(, 4])
5. Empiler ([(, 4])
6. Inserer ([9, 0]...
131
12. Inserer ([4, 0])
13. Empiler ([*, 2])
14. Inserer ([6, 0])
15. Depiler ([*, 2]); inserer ([*, 2]); Depiler ([(, 4]...
132
1. Empiler ([~, 3])
2. Inserer ([3, 0])
3. Depiler ([~, 3]); inserer ([~, 3]); Empiler ([+, 1])
4. Inserer ([2, 0])
5....
133
1. Empiler ([(, 4])
2. Inserer ([1, 0])
3. Empiler ([+, 1])
4. Inserer ([3, 0])
5. Empiler ([*, 2])
6. Inserer ([4, 0]...
134
Transformation infixée postfixée (Pseudo Algorithme):
Lire l’expression infixée terme par terme:
Si c'est un opérande ...
135
Transformation infixée postfixée (Déclaration):
EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
Type Terme...
136
Transformation infixée postfixée (Algorithme):
EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
InfixeAPost...
137
Transformation infixée postfixée (Algorithme):
EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
Si X.prio =...
138
3. Donner l’algorithme d’évaluation d’une expression
postfixée.
Exemples illustratif:
EXERCICE 9 (EVALUATION D’EXPRESS...
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. d...
140
1. empiler(3)
2. depiler(3) ; empiler(0-3)
3. empiler(2)
4. depiler (2); depiler (-3); empiler( -3 + 2)
5. empiler(5)
...
141
1. empiler(1)
2. empiler(3)
3. empiler(4)
4. depiler (4); depiler (3); empiler( 3 * 4)
5. depiler (12); depiler (1); e...
14
2
Evaluation d'une expression postfixée (Pseudo Algorithme)
Lire l’expression postfixée terme par terme:
Si c’est un op...
14
3
Evaluation d'une expression postfixée (Déclaration)
EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
Type ...
144
Evaluation d'une expression postfixée (Fonction Calcul)
EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
Pr...
Evaluation d'une expression postfixée (Algorithme)
EXERCICE 9 (EVALUATION D’EXPRESSION ARITHMÉTIQUE POSTFIXÉE)
EVAL_Postfi...
SOURCES DE CE COURS
N. EL-ALLIA , Cours d’Algorithmique et Structures de données
dynamiques, Ecole nationale Supérieure d’...
Prochain SlideShare
Chargement dans…5
×

Chapitre 3 structures séquentielles

4 513 vues

Publié le

structures séquentielles: listes linéaires chainées, files d'attente et piles

Publié dans : Formation
  • Soyez le premier à commenter

Chapitre 3 structures séquentielles

  1. 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. 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. 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. 4. PARTIE I: LISTES LINÉAIRES CHAÎNÉES (LLC)
  5. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 63. Faut-il utiliser un tableau ou une LLC? CONCLUSION 63
  64. 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. 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
  66. 66. PARTIE II: FILES D’ATTENTE
  67. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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)
  110. 110. PARTIE III: PILES
  111. 111. PLAN DE LA PARTIE III Définition Modèle Implémentation Représentation statique Représentation dynamique Utilisation 111
  112. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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

×