Chapitre 3 structures séquentielles

CHAPITRE III:

STRUCTURES SÉQUENTIELLES

Université Saad Dahlab – Blida1

Faculté des Sciences

Département d’Informatique

Licence d’Informatique

Semestre 3 (2ème année)

Algorithmique et Structures de Données

Mme AROUSSI

2016-2017

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

PLAN DU CHAPITRE III

I. Introduction

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

III. Files d’Attente (FIFO)

IV. Piles (LIFO)

� 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

PARTIE I:

LISTES LINÉAIRES CHAÎNÉES

PLAN DE LA PARTIE I

� Définitions

� Modèle des LLC (MLLC)

� Algorithmes sur les listes

� Listes particulières

� Représentation contigüe

� Conclusion

� 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

� 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

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

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, …..)

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

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

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

MODÈLE DE LLC (MLLC)

Modules Rôle

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

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

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

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

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

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

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

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

modèle :

MODÈLE DE LLC (MLLC)

Modules Implémentation en langage C

Allouer( P)struct Maillon *Allouer ( )

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

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

{free (p);}

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

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

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

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

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

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

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

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

� 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

� 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.

� 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.

� 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.

� 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.

� 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

� Soient la liste suivante:

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

IMPRESSION

2 10 5 -1 6

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

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

FTQFin

� La longueur de cette liste = 5

LONGUEUR

2 10 5 -1 6

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

Cpt ++P ←suivant (P)

FTQRetourner (Cpt)Fin

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

� Si v= 1 alors

la fonction retourne nil.

RECHERCHE

2 10 5 -1 6

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

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

Sinon P ←suivant (P)

FTQRetourner (nil)Fin

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

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

RECHERCHE

2 10 5 -1 6L

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

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

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

situations :

1. Insertion au début de la liste

2. Insertion à la fin de la liste

3. Insertion à une position donnée

INSERTION

� Cas 1: Insertion au début

INSERTION

-1 5 10 26

Paff_suiv (P, L)

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

� Cas 2: Insertion à la fin.

INSERTION

2 10 5 -1 6

aff_suiv (Q, P)

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

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

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

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

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

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

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

ensuite refaire le chaînage comme suit;

INSERTION

2 10 5 -1

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

(2) aff_suiv (Q, P)

ALGORITHMES SUR LES LLCSINSERTION

2 10 5 -1

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

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

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

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

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

(2) aff_suiv (Q, P)

� Pour créer une liste:

1. Allouer un nouveau maillon

2. Initialiser le maillon avec la valeur lue

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

a. Insertion à la fin

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

CRÉATION

val suiv

??? ???

val suiv

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

CRÉATION

2 10 5 -1

aff_suiv (Q, P)

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

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

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

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

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

lire (v) InsererLLC_Fin(L, v)

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

� Cas 2: Insertion au début

CRÉATION

-1 5 10 2

Paff_suiv (P, L)

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

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

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

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

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

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

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

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

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

SUPPRESSION

� Exemple 1: Suppression v = 5

� Exemple 2 : Suppression v = 2

SUPPRESSION

2 10 5 -1 6

2 10 5 -1

SUPPRESSION

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

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

FTQSi (P ≠ nil) alors

Si Q = nil alorsL ← suivant (P);

Sinon aff_suiv(Q,suivant (P));

libérer (P)Fin

/* rechercher le premier maillon contenant v*/

/* Suppression du premier maillon */

� Suppression de tous les maillons contenant la valeur v

SUPPRESSION

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

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

FTQSi (P ≠ nil) alors

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

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

libérer (P)P ��S;

/* rechercher le premier maillon contenant v*/

/* Suppression du premier maillon */

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

� Deux situations se présentent:

� k = 1, supprimer le premier maillon

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

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

refaire le chaînage comme suit;

SUPPRESSION

2 10 5 -1

� Suppression à une position donné « k ».

SUPPRESSION

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

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

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

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

DESTRUCTION

2 10 5 -1 6

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

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

FTQFin

2 10 5 -1 6

� 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

� Impression d’une LLC circulaire

LISTE CIRCULAIRE (QUELQUES ALGORITHMES)

2 10 5 -1L

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

P←LRépéter

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

Jusqu’à P=LFin

� Recherche le premier maillon contenant la valeur v

2 10 5 -1L

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

P←LRépéter

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

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

Retourner (nil)Fin

� Insertion dans une LLC circulaire

2 10 5 -1

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

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

Sinon aff_suiv(P , suivant (L))

aff_suiv (L, P)

� Construction d’une LLC circulaire

� Construire une LLC unidirectionnel

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

2 10 5 -1 6L

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

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

aff_suiv (P, L);Fin

� Construction d’une LLC circulaire

2 10 5 -1 6L

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

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

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

� 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

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

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

chaînage

2 10 5 -1L

LISTES PARTICULIÈRES LISTE CIRCULAIRE

(QUELQUES ALGORITHMES)

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

P←Lrépéter

Q←PP ←suivant (P)

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

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

L ← nilSinon

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

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

//rechercher le mailloncontenant la valeur v

� Destruction d’une LLC circulaire

2 10 5 -1L

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

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

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

FTQLibérer (P); L ←nil;

� Liste bidirectionnelle ou Liste Doublement

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

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

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

précédent).

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

LISTE BIDIRECTIONNELLE

V1 V2 V3 V4 V5

Queue val suiv

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

� Un champ contenant la donnée.

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

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

val suiv

type MaillonBD = Structure

val : typeqq

suiv: * MaillonBD

prec:*MaillonBD

type ListeBD= Structure

Tête: * MaillonBD

Queue:*MaillonBD

Var L: ListeBD

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

opérations suivantes :

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

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

� Impression d’une LLC Bidirectionnelle

LISTE BIDIRECTIONNELLE (QUELQUES ALGORITHMES)

2 5 -1 6

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

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

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

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

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

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

� Recherche d’une valeur dans une LLC Bidirectionnelle

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

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

Retourner (nil)Fin

2 5 -1 6

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

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

Retourner (nil)Fin

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

2 5 -1 6

QueueP

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

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

� Insertion au début de la liste

Aff_suiv (P, Tete)Tete

-1 5 26

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

� Insertion à la fin de la liste.

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

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

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

Aff_suiv (Queue, P)Tete

2 5 -1 6

Aff_prec (P, Queue)

� Insertion à une position donnée

2 5 -1 6

QueueS6

(1)(2)

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

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

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

� Construction d’une LLC Bidirectionnelle

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

Aff_suiv (Q, P)Tete

2 5 -1 6

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);

� Construction d’une LLC Bidirectionnelle

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

Aff_suiv (P, T)

Tete Queue

-1 5 26

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);

2 5 -1 6

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

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

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

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

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

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

libérer (P)

QueueTete P

� Destruction d’une LLC Bidirectionnelle

2 5 -1 6

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

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

Init (L);Fin

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

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

Init (L);Fin

� Liste bidirectionnelle circulaire est une LLC à double

sens et dont le dernier maillon pointe sur le premier

maillon et le premier maillon pointe sur le dernier

maillon.

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

écrire des algorithmes sur ce type de liste:

MLLCbdcir = MLLCbd

LISTE BIDIRECTIONNELLE CIRCULAIRE

V1 V2 V3 V4 V5

� 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

12 8 23 45

Vide Val Suiv

F 12 4

F 23 7

F 45 -1

Tête = 0

� 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

F 45 -1

Définition de la structure :

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

var Liste : tableau [Max] de element

Tête = 0

REPRÉSENTATION CONTIGÜE

DÉFINITION

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

Modules Rôle

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

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

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

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

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

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

val » de la case L[P]

REPRÉSENTATION CONTIGÜEMODÈLE

Modules Code Complexité

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

L[i] ←fauxRetourner(i)

Retourner (-1)

O(max)

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

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

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

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

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

REPRÉSENTATION CONTIGÜEMODÈLE

Faut-il utiliser

un tableau ou

une LLC?

CONCLUSION

Tableau non ordonné LLC unidirectionnelle non ordonné

Accès à un élément

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

Ajout Recherche séquentielle d’une case

vide O(n)

Chaînage:

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

Suppression Décalage O(n)

Chaînage:

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

Définition de la relation suivant:

Implicitedéfinie par la contiguïté

des composantes du tableau

ExpliciteOn peut la modifier , i.e. les

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

CONCLUSION

Tableau non ordonné LLC unidirectionnelle non ordonné

encombrement

La relation suivant étant

implicite, il n’y a pas besoin

d’espace supplémentaire pour

son codage.

l’encombrement de chaque

maillon est augmenté de la

taille du pointeur suivant

Encombrement

total selon le

besoin

avec l’allocation statique,

l’encombrement d’un tableau

est constant (fixé d’avance).

avec l’allocation dynamique

des maillons, le nombre de

maillons d’une LLC

correspond au nombre

d’éléments effectivement

présents

CONCLUSION

PARTIE II:

FILES D’ATTENTE

PLAN DE LA PARTIE II

� Définition

� Utilisation

� Modèle

� Implémentation

� Représentation statique

� Représentation dynamique

� File d’attente avec priorité 67

� 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

� 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

� 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

� 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

� 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

� 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

TYPE File_Attente = STRUCTURE

Elements : TABLEAU[Max] de Typeqq

Queue : ENTIER

VAR F : File_Attente

V1 V2 V3 V4 V5 V6

File_Attente

Eléments

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

� 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

IMPLÉMENTATION STATIQUE PAR TABLEAU CIRCULAIRE

V0 V1 V2 V3 V4 V5

Tête = 8Queue = 5

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

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

Tête, Queue : ENTIER

VAR F : File_Attente

File_Attente

Eléments

V2 V3 V4 V5

Tête = 1 Queue = 5

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

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

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

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

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

F.elements[F.Queue] ← X

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

X ← F.elements[F.Tete]

� 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

V0 V1 V2 V3 V4

Tête Queue

TYPE Maillon = STRUCTURE

val : typeqq

suiv: * Maillon

Tête, Queue : *Maillon

VAR F: File_Attente

File_Attente

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)

F.Tete ← P

F.Queue ← P

P ← F.Tete

X ← Valeur(F.Tete)

F.Tete ← Suivant(F.Tete)

Liberer(P)

� 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É

�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).

TYPE prog = STRUCTURE

prio : ENTIER

PSW : typeqcq

Elements : TABLEAU[Max] de prog

Queue : ENTIER

(3,PSW)

(2,PSW)

(1,PSW)

(0,PSW)

Initfile(F) F.Queue ←-1

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

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

X ← F.Elements[0]

POUR I ← 0 à F.Queue - 1

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

F.Queue ← F.Queue – 1

(3,PSW)

(2,PSW)

(1,PSW)

(0,PSW)

� Enfiler (F, (2, PSW))

(3,PSW)

(2,PSW)

(1,PSW)

(0,PSW)

� 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),

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

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

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

//décaler les programmes moins prioritaires

J � F.QueueTQ (J≥I) faire

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

//insérer le programme X

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

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

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

trouver la bonne position où enfiler X

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

//insérer le programme X

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

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

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

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

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

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

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

prio : ENTIER

PSW : typeqcq

Elements : TABLEAU[Max] de prog

Queue, Tete : ENTIER

(3,PSW)

(2,PSW)

(1,PSW)

(0,PSW)

TeteQueue

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]

(3,PSW)

(2,PSW)

(1,PSW)

(0,PSW)

(3,PSW)

(2,PSW)

(1,PSW)

(0,PSW)

(1,PSW)

(0,PSW)

(3,PSW)

(2,PSW)

(1,PSW)

(0,PSW)

(3,PSW)

(2,PSW)

Queue Tete

� 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.

� 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)

(0,PSW)

(3,PSW)

(2,PSW)

Queue Tete

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

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

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

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

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

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

� Enfilement:

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

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

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

(principe de tri par insertion)

(2,PSW)

(3,PSW)

(2,PSW)

(1,PSW)

(0,PSW)

(3,PSW)

(2,PSW)

(1,PSW)

(0,PSW)

(2,PSW)

(3,PSW)

(2,PSW)

(1,PSW)

(0,PSW)

(3,PSW)

(2,PSW)

(1,PSW)

(0,PSW)

(3,PSW)

(2,PSW)

(1,PSW)

(0,PSW)

(2,PSW)

(1,PSW)

(0,PSW)

(3,PSW)

(1,PSW)

(0,PSW)

(2,PSW)

(3,PSW)

(2,PSW)

(1,PSW)

(0,PSW)

(3,PSW)

(2,PSW)

(1,PSW)

Queue Tete

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

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

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

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

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

//mettre à jour la Tête

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

(3,PSW)

Tête Queue

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

prio : ENTIER

PSW : typeqcq

val : prog

suiv: * Maillon

TêTe, Queue : *Maillon

Initfile(F) F.Tete ← NIL

F.Queue← NIL

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

P ← F.Tete

X ← Valeur(F.Tete)

F.Tete ← Suivant(F.Tete)

Liberer(P)

(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)

IMPLÉMENTATION DYNAMIQUEEnfiler(F,X)

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

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

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

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

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

S← suivant (S)

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

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

Sinon //insertion au milieu

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

PARTIE III:

PLAN DE LA PARTIE III

� Définition

� Modèle

� Implémentation

� Représentation statique

� Représentation dynamique

� Utilisation

� 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é.

� 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

3Sommet

DépilementEmpilement

� 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

� 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

� 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

DépilementEmpilement

TYPE Pile= STRUCTURE

Sommet : ENTIER

VAR P : Pile

Eléments

Sommet =5 V5

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 »

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

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

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

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

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

� Les opérations de base sont :

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

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

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

V4 V3 V2 V1 V0

Sommet (Tête)Empilement

Dépilement

V4 V3 V2 V0 V1

Sommet

val : typeqq

suiv: * Maillon

VAR sommet: *Maillon

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)

� Analyse syntaxique : qui est une phase de la

compilation qui nécessite une pile.

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

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

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

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

� ouvrante, elle est empilée ;

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

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

UTILISATION

� 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

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 +

1. Ecrire les expressions suivantes en postfixée:

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

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

comme suit:

Expressions en infixée Expressions en postfixée

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

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

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

1262. Donner la LLC qui présente cette expression

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

Type Terme = structure

Op : Chaines de caractères;

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

Type maillon = structure

Val : Terme;

Suiv : * maillon ;

Prio Signification

0 Opérande

1 Opérateur binaire (+, -)

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

3 Opérateur unaire ( - unaire)

4 Parenthèse ouvrante ou fermante

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

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

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

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

[‘*’, 2]

Linfixe

� La LLC qui présente cette expression

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

[‘7’, 0]

[‘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+*

3. Ecrire l’algorithme qui permet de transformer une

expression infixée en une expression postfixée.

� Exemples illustratif:

Expressions en infixée Expressions en postfixée

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

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

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

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]

[(, 4][(, 4]

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

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

10 - 11

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

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]);

[*, 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]

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]

[-, 1]

[*, 2]

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

[-, 1]

[/, 2]

[+, 1]

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]

[+, 1]

[(, 4]

[+, 1][*, 2]

[(, 4]

[+, 1]

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

[*, 2]

� 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

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

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

Type Maillon = structure

Val : Terme;

Suiv : *Maillon ;

Type Pile= structure

Elements : tableau[Max] de Terme

Sommet : entier

Prio Signification

0 Opérande

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

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

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

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

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

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

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

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

FTQEmpiler(T[i].valeur,P)

FSIQ�suivant (Q);

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

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

FTQRetourner (Lpostfixe)

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

postfixée.

� Exemples illustratif:

Expressions en

infixée

Expressions en

postfixée

Evaluation

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

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

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

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

« 10 »

« 11 »

« 9 »

« 8 »

« 5 »5

« 6 »5

« 7 »

« 1 »

« 2 »

« 3 »5

« 4 »

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

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)

« 7 »

« 8 »

3« 1 »

-3« 2 »

« 3 »

« 4-6 »

« 9 »

« 10 »

-13« 12 »

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

1. empiler(1)

2. empiler(3)

3. empiler(4)

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

6. empiler(2)

8. empiler(5)

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

10. depiler (75)

« 5 »

« 6 »

1« 1 »

« 2 »

« 4 »

15« 7-8 »

75« 9 »

« 3 »134

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

� 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

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

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

Type Maillon = structure

Val : Terme;

Suiv : *Maillon ;

Type Pile1= structure

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

Sommet : entier

Prio Signification

0 Opérande

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

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

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

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

Res �ConvertirEntierChaine(Z)Fin

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

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

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

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

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

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

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

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

SOURCES DE CE COURS

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

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

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

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

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

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

Saad Dahlab de Blida, 2014, Disponible sur

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

donnees/nouveau-programme .

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

Mohamed Khider de Biskra, 2012, Disponible sur univ-

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

Chapitre 3 structures séquentielles

Education

Chapitre 1 : Les structures de la peau

Chapitre 8 Structures tridimensionnelles des protéines Structure secondaire

Chapitre 4 les structures organisationnelles

Chapitre 2 Structures de données de base : les tableaux tableaux.pdf · Chapitre 2 Structures de données de base : les tableaux 1. introduction 2. présenter le concept de tableaux

CHAPITRE 2 : LES STRUCTURES DE GRANDES PORTÉES

Fouille de données séquentielles pour l’extraction d ... · Fouille de données séquentielles pour l’extraction d’information dans les textes ... fération des données textuelles

Chap. 1Structures séquentielles : listes linéaires 1

Chapitre 4 LE CALCUL DE STRUCTURES ET LA TENUE EN FATIGUE

CHAPITRE 6 Structures de données Les Tableaux · CHAPITRE 6 Structures de données Les Tableaux : ... DE entiers ; VAR Tab : TypeTableau ; En langage C : int Tab [10] ; ... de fin

Chapitre I : Les mutations des structures de la production

Chapitre 1 : Évaluation et diagnostic des structures en béton

Chapitre 2 Spectroscopie de rotation - Structures moléculaires

Chapitre 03 : Structures de contrôle

Structures séquentielles

Décisions séquentielles dans l'incertain : nouvelles approches par

Ecrire à partir d’images séquentielles au CP

Systèmes de logiques séquentielles-Bascules

Méthodes d'optimisation séquentielles et parallèles

Chapitre 1 Effets de taille, synergies et structures de marché

CHIMIE ORGANIQUE I. STRUCTURES ET LIAISONS AU SEIN DES MOLÉCULES ORGANIQUES CHAPITRE 1 Vollhardt – Chapitre 1