Algorithmique

Évaluation d’expressions
Luc Brun
luc.brun@greyc.ensicaen.fr

Évaluation d’expressions – p.1/38

Plan
Les différents types d’expressions
Expression complètement parenthésée (ECP),
Expression préfixée (EPRE),
Expression postfixée (EPOST),
Expression infixée (EINF).
Évaluation d’expressions
postfixée,
complètement parenthésée,
Conversion d’expressions
ECP à postfixée,
infixée à postfixée.

Évaluation d’expressions – p.2/38

Définition d’une expression
Définition : Une expression est une suite de variables combinées par un
ensemble d’opérateurs avec éventuellement un jeux de parenthèses ouvrantes
et fermantes.
Exemple :












NB : On ne fait pas intervenir de constantes ou de fonctions (petite
simplification).
L’évaluation d’une expression implique la définition d’un environnement
(affectation de chaque variable à une valeur).

Évaluation d’expressions – p.3/38

Les opérateurs
Opérateurs binaires
opérateurs arithmétiques


 



opérateurs logiques





 
 






 



Opérateurs unaires
opérateurs arithmétiques





NB : , .






opérateurs logiques 



Évaluation d’expressions – p.4/38

Expression complètement parenthésée
Une expression complètement parenthésée se construit à partir des règles
suivantes :
1. Une variable est une ECP,
2. si et sont des ECP et un opérateur binaire, alors ( est une ECP,


#

#
!

"

"
3. si est une ECP et un opérateur unaire alors est une ECP,


!

$
!
4. Il n’y a pas d’autre ECP que celles formées par les 3 règles précédentes.

Évaluation d’expressions – p.5/38

Grammaire des ECP
Grammaire BNF (Backus-Naur Form)
ecp ( ecp optbin ecp ) |







%
( optun ecp ) |




variable



optbin &

&

&

&

&

&

&

&

&

&

&
 







%




optun
&

&








variable
&
&

&


&'


Évaluation d’expressions – p.6/38

Exemples d’ECP
ECP conformes :
((A+B)*C)
(((A/B)=C)et(E<F))
( A)


ECP non conformes :

(A)
((A+B))
A B


Évaluation d’expressions – p.7/38

Expressions préfixées
Les expressions préfixées (EPRE) se construisent à partir des règles suivantes :

(
1. une variable est une EPRE,
2. si et sont des EPRE et un opérateur binaire alors est une EPRE,

#
!

"

!
"
3. Si est une EPRE et un opérateur unaire, alors est une EPRE,
!

$
!
4. il n’y a pas d’autres EPRE que celles formées à partir des règles

)
précédentes.

Évaluation d’expressions – p.8/38

Grammaire des EPRE
Règles :
epre optbin epre epre |









%
optun epre |






variable


optbin &

&

&

&

&

&

&

&

&

&

&
 







%




optun
&

&








variable
&
&

&


&'


NB : Seule la première règle a été changée.

Évaluation d’expressions – p.9/38

Exemples d’EPRE
Expressions correctes :
EPRE ECP
+-ABC ((A-B)+C)
et non A B C ((non(A B))et C)



non = + A B C (non ((A+B)=C))
Expressions incorrectes
A-+BC
non B C

Évaluation d’expressions – p.10/38

Expressions postfixées
Expressions utilisées par les calculatrices HP (cf TP Web) et données par les
règles :
(

1. une variable est une EPOST,

2. si et sont des EPOST et un opérateur binaire alors est une

#
!

"

!
"
EPOST,
3. Si est une EPOST et un opérateur unaire, alors est une EPOST,
!

$
4. il n’y a pas d’autres EPOST que celles formées à partir des règles

)
précédentes.

Évaluation d’expressions – p.11/38

Grammaire des EPOST
Règles :
epost epost epost optbin |









%
epost optun |







variable


optbin &

&

&

&

&

&

&

&

&

&

&
 







%




optun
&

&








variable
&
&

&


&'


NB : Seule la première règle a été changée.

Évaluation d’expressions – p.12/38

Exemples d’EPOST
ECP EPRE EPOST
(((A+B)-C)/D) /-+ABCD AB+C-D/
((A < B) et (non C)) et < A B non C A B < C non et
((non (A < B)) et (C>D)) et non < A B > C D A B < non C D > et

Évaluation d’expressions – p.13/38

Expressions Infixées
Écriture ECP sans ambiguï té mais parfois un peu lourde.
Suppressions de certaines parenthèses par données implicites :

*
1. Priorité des opérateurs














+

2. Priorité à gauche pour les opérateurs de même priorité














+

Les parenthèses imposent des priorités

















+

Évaluation d’expressions – p.14/38
Priorité des opérateurs
Opérateur Priorité
( 0
1

 
 






 



ou, +, - 2
et, *, / 3
, non 4
 
,


Évaluation d’expressions – p.15/38

Grammaire des EINF
: expression éventuellement présente un nombre quelconque de fois.



!-.

einf esimple op1 esimple

 




%
esimple terme op2 terme

 



%
terme facteur op3 facteur

 



%

facteur variable |



%

op4 facteur |





( einf )


op1
&

&

&

&

&
 







%

op2
&

&





op3
&

&




%

op4
&

&








variable
&
&

&


&'


Évaluation d’expressions – p.16/38

Exemples d’EINF
EINF ECP
A*B+C-D (((A * B) +C)-D)
A+B*C (A+(B * C))
A=B et C>D ((A=(B et C))> D)
A et B ou C et D ((A et B) ou (C et D))
A et (B ou C) et D ((A et (B ou C)) et D)
non A et B ou C et non D (((non A) et B) ou (C et (non D)))

Évaluation d’expressions – p.17/38

Évaluation d’expression
L’évaluation s’effectue par rapport à un environnement (affectation des
variables).
Idée : Ordonnancer l’évaluation de façon à ce que l’évaluation d’une
opération s’effectue sur
des variables ou
des expressions déjà évaluées.
Soit appliquant sur et .
/

"
evaluation(S) = opération( ,
#
si variable(x) alors valeur(x) sinon evaluation(x),
si variable(y) alors valeur(y) sinon evaluation(y))

Évaluation d’expressions – p.18/38

Exemple d’évaluation
Soit à évaluer S=(A+(B*C)) avec .




(
*

)



evaluation(S) = opération(+,A,évaluation(B*C))
= opération(+,A,opération(*,B,C))
= opération(+,2,opération(*,3,4))
= opération(+,2,12)
= 14

Évaluation d’expressions – p.19/38

Évaluation d’une expression postfixée
Les opérandes apparaissent avant l’opération.
L’évaluation d’une opération fournie soit le résultat soit un nouvel opérande.
10 3 + 5 6 - - = 13 5 6 - -
= 13 -1 -
= 14
Idée :
empiler les opérandes,
dépiler pour effectuer une opération.

Évaluation d’expressions – p.20/38

Exemple d’évaluation d’une EPOST
évaluons A B * C D + / avec A=2,B=3,C=2,D=1

3
2 6
2
pile vide empiler A empiler B evaluer *
AB*CD+/# B*CD+/# A *CD+/# AB CD+/#


0

0
1
2 3
2 2
6 6
6
empiler C empiler D évaluer + evaluer /
AB* D+/# AB*C +/# AB*CD /# AB*CD+ #




0

Évaluation d’expressions – p.21/38

Évaluation d’EPOST : Énumération des cas
Soit epost[1..MAX] une chaî ne de caractères contenant une EPOST et une

1
position dans la chaî ne.
Si epost[i]=’#’ : l’évaluation est terminé. Résultat en sommet de pile.
Si epost[i] ’#’
 


Si epost[i] est une variable : empiler sa valeur

Si epost[i] est un opérateur : on dépile son (ou ses 2 opérandes), on
effectue l’opération et on empile le résultat.

Évaluation d’expressions – p.22/38

Évaluation d’EPOST : l’algorithme
fonction evalPost (epost : Tableau[ ] deCaratère ) : Réel


2
Déclaration i :Entier,valG,valD :Réel,p : Pile
début
p creer() sinon
3

i 1 valD dépiler(p)
3

3
tant que epost[i] ’#’ faire valG dépiler(p)
 


3
si variable(epost[i]) alors valD

3
empiler(epost[i],p) oper2(valG,epost[i],valD)
sinon empiler(valD,p)
si unaire(epost[i]) alors finsi
valD dépiler(p) finsi
3

valD oper1(epost[i],valD) i i+1

3

3
fintantque
empiler(valD,p) retourner sommet(p)
Évaluation d’expressions – p.23/38
Évaluation d’ECP
Utilisation d’une pile à travers trois types d’actions :
1. Si le symbole lu est un opérateur : on l’empile
2. si c’est une variable : on empile sa valeur,
3. Si c’est une parenthèse droite : on dépile une sous expression et on empile
le résultat.

Évaluation d’expressions – p.24/38

Évaluation d’ECP : Exemple
évaluons (A * (B+C)) avec A=2,B=3,C=1.

3
* *
2 *
2 2
2
( *(B+C))# (A (B+C))# (A* B+C))# (A*( +C))#







0

0
0

1
+
+ 4
3
3 * 8
*
* 2
2
2
(A*(B C))# (A*(B+ ))# (A*(B+C )# (A*(B+C) #






Évaluation d’expressions – p.25/38

0
0

0
Évaluation d’ECP : l’algorithme
fonction evalEcp (ecp : Tableau[ ] deCaratère ) : Réel


2
Déclaration i :Entier,op :Caratère,valG,valD :Réel,p : Pile
début
p creer() valD dépiler(p)
3

3
i 1 op dépiler(p)
3

3
tant que ecp[i] ’#’ faire si unaire(op) alors
 


si variable(ecp[i]) alors empiler(oper1(op,valD),p)

empiler(valeur(ecp[i]),p) sinon
continuer valG dépiler(p)

3
finsi emp.(op2(valG,op,valD),p)
si operateur(ecp[i]) alors finsi
empiler(ecp[i],p) finsi
continuer i i+1
3

finsi fintantque
si ecp[i]=’)’ alors retourner sommet(p) Évaluation d’expressions – p.26/38
Conversion ECP à EPOST
ECP lisibles, tapé par exemple dans un code source,
EPOST directement interprétable par une machine.
Nécessité de convertir.
Remarque : Lors de la lecture d’une ECP on rencontre les opérandes dans le
même ordre que dans l’EPOST. Seul l’opérateur est placé à la fin.










%
Idée : Empiler les opérateurs et les dépiler sur les parenthèses fermantes.
Opérateur : empiler,
variable : écrire dans chaî ne résultat.
parenthèse fermante : dépiler un opérateur
parenthèse ouvrante : ne rien faire.

Évaluation d’expressions – p.27/38

Exemple de conversion
Convertissons (A * (B+C))

* * *
A A A AB
( *(B+C))# (A (B+C))# (A* B+C))# (A*( +C))#







0

0
+ + 0
*
* *
AB ABC ABC+ ABC+*
(A*(B C))# (A*(B+ ))# (A*(B+C )# (A*(B+C) #






0
0

0
Évaluation d’expressions – p.28/38
Conversion ECP à EPOST : l’algorithme
procédure convEcpEpost ( E ecp : Tableau[ ] deCaratère , S


2
epost : Tableau[ ] deCaratère )


2
Déclaration indecp,indepost :Entier,p : Pile
début
p creer() indepost indepost+1
3

3
indecp 1 continuer
3

indepost 1 finsi
3

tant que ecp[indecp] ’#’ faire si ecp[i]=’)’ alors

 


si operateur(ecp[i]) alors epost[indepost] dépiler(p)

3
empiler(ecp[i],p) indepost indepost+1

3
continuer finsi
finsi indecp indecp+1

3
si variable(ecp[i]) alors fintantque
epost[indepost] ecp[indecp] epost[indepost] #
3

3
fin
Évaluation d’expressions – p.29/38
Conversion ECP/EPOST : Amélioration
Détection d’erreurs de syntaxe dans l’ECP.
La pile ne doit pas être vide avant la fin (trop de parenthèses fermantes) et
vide à la fin (pas assez).
Un caractère d’ECP est soit :
un opérateur,
une variable,
une parenthèse fermante,
une parenthèse ouvrante.

Évaluation d’expressions – p.30/38

Conversion EINF à EPOST
Problème compliqué par l’absence de parenthèses. On applique les règles
suivantes :
variable : empiler.
opérateur : L’empiler. Il faut dépiler auparavant tous les opérateurs de
priorité supérieure ou égale.
parenthèse gauche : Empiler. Délimite une sous expression.
parenthèse droite : dépiler jusqu’à une parenthèse gauche.

Évaluation d’expressions – p.31/38

Exemple de conversion (1/2)
Convertissons A*B+C/(D+E)

* * +
A A AB A B*
*B+C/(D+E)# A B+C/(D+E)# A* +C/(D+E)# A*B C/(D+E)#





0

0
( (
/
+ / /
+
+ +
A B *C A B *C A B* C + A B* C D
A*B+ /(D+E)# A*B+C (D+E)# A*B+C/ D+E)# A*B+C/( +E)#





0
0

Évaluation d’expressions – p.32/38

Exemple de conversion (2/2)
A*B+C/(D+E)

+ +
(
( (
/
/ /
+
+ +
A B *C D A B *C D A B* C D E
A*B+C/( +E)# A*B+C/(D E)# A*B+C/(D+ )#

4

0

0
0

/
+
A B* C D E + A B* C D E + / +
A*B+C/(D+E # A*B+C/(D+E)#


Évaluation d’expressions – p.33/38

0
Conversion EINF/EPOST : Points délicats
Trois points délicats :
Empilement d’une opération,
Rencontre d’une parenthèse fermante,
Fin de l’algorithme et vidage de la pile.

Évaluation d’expressions – p.34/38

Empilement d’une opération
procédure traiterOpt ( E op :Caratère , S epost : Tableau[ ]


2
deCaratère E/S p : Pile,indpost : Naturel )
Déclaration dépil : Booléen,élément : Caratère
début
dépil non vide(p)
3

tant que dépil faire

si priorité(sommet(p)) priorité(op) alors


élément depiler(p)
3

epost[indpost] élément
3

indpost indpost+1
3

dépil non vide(p)

3

sinon
dépil faux
3

finsi
fintantque
empiler(op) Évaluation d’expressions – p.35/38
Rencontre d’une parenthèse fermante
procédure traiterPF ( S epost : Tableau[ ] deCaratère , E/S


2
indpost : Naturel,p : Pile )
Déclaration élément : Caratère
début
élément dépiler(p)
3

tant que élément ’(’ faire

 


epost[indpost] élément
3

indpost indpost+1
3

élément depiler(p)
3

fintantque
fin

Évaluation d’expressions – p.36/38

Vidage de la pile
procédure traiterPF ( S epost : Tableau[ ] deCaratère , E/S


2
indpost : Naturel,p : Pile )
Déclaration élément : Caratère
début
tant que non vide(p) faire
epost[indpost] depiler(p)
3

indpost indpost+1
3

fintantque
epost[indpost] ’#’
3

fin

Évaluation d’expressions – p.37/38

Conversion EINF/EPOST : l’algorithme
procédure convEinfEpost ( E einf : Tableau[ ] deCaratère , S


2
epost : Tableau[ ] deCaratère )


2
Déclaration indinf,indpost :Entier,p : Pile
début
p creer() indpost indpost+1
3

3
indinf 1 continuer
3

indpost 1 finsi
3

tant que einf[indinf] ’#’ faire si ecp[i]=’)’ alors

 


si operateur(einf[indinf]) alors traiterPF(epost,indpost,p)

sinon
traiterOpt(einf[indinf],epost,indpost,p) empiler(’)’) ;
continuer finsi
finsi indinf indinf+1

3
si variable(einf[indinf]) alors fintantque
epost[indpost] einf[indinf] traiterFin(epost,indpost,p)
3

Évaluation d’expressions – p.38/38