Bibdoc 2024 - L’Éducation aux Médias et à l’Information face à l’intelligence...
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
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
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
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]
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)
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
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)
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*
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
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