EIDIA EUROMED

ALGO AVANCEE

Pr ALAMI Zakariae
 Exemple pratique

Un exemple simple d'analyseur syntaxique utilisant une pile et une file en langage C’est
l'analyseur syntaxique pour vérifier si une expression arithmétique est correctement syntaxée.

Supposons que l'expression arithmétique est "2 + 3 * (4 - 1)".

L'analyseur syntaxique utilise une pile pour stocker les parenthèses ouvrantes rencontrées lors
de la lecture de l'expression, et une file pour stocker les opérateurs et les opérandes.

Le processus de vérification de la syntaxe de l'expression est le suivant :

1. La file est initialisée avec les éléments de l'expression "2 + 3 * (4 - 1)" dans l'ordre de
leur apparition.
2. Le premier élément de la file est lu et vérifié s'il s'agit d'un opérande. Dans ce cas, il
est ajouté à la pile.
3. Le deuxième élément de la file est lu et vérifié s'il s'agit d'un opérateur. Dans ce cas, il
est ajouté à la file.
4. Le troisième élément de la file est lu et vérifié s'il s'agit d'une parenthèse ouvrante.
Dans ce cas, elle est ajoutée à la pile.
5. Le quatrième élément de la file est lu et vérifié s'il s'agit d'un opérande. Dans ce cas, il
est ajouté à la pile.
6. Le cinquième élément de la file est lu et vérifié s'il s'agit d'un opérateur. Dans ce cas, il
est ajouté à la file.
7. Le sixième élément de la file est lu et vérifié s'il s'agit d'une parenthèse ouvrante. Dans
ce cas, elle est ajoutée à la pile.
8. Le septième élément de la file est lu et vérifié s'il s'agit d'un opérande. Dans ce cas, il
est ajouté à la pile.
9. Le huitième élément de la file est lu et vérifié s'il s'agit d'une parenthèse fermante.
Dans ce cas, la dernière parenthèse ouvrante ajoutée à la pile est retirée de la pile.
10. Le neuvième élément de la file est lu et vérifié s'il s'agit d'un opérateur. Dans ce cas, il
est ajouté à la file.
11. Le dixième élément de la file est lu et vérifié s'il s'agit d'un opérande. Dans ce cas, il
est ajouté à la pile.
12. La file est maintenant vide et la pile ne contient qu'un élément. Si la pile contient plus
d'un élément ou si une parenthèse ouvrante n'a pas de parenthèse fermante
correspondante, l'expression n'est pas correctement syntaxée.

Dans cet exemple, l'expression arithmétique est correctement syntaxée car la pile ne contient
qu'un élément à la fin du processus.

Le code en c est dans teams

 Bonus (liste piles files en Python) réalisation optionnelle
PILES

class Pile1:
"""
Je représente une pile, implémentée grâce aux listes python.
"""

def __init__(self):
"""
Crée une pile vide
"""
self._tableau = []

def est_vide(self):
"""
Renvoie True ssi je suis une pile vide.
"""
return len(self._tableau) == 0

def taille(self):
"""
Renvoie ma taille (en nombre d'éléments empilés)
"""
return len(self._tableau)

def empiler(self, valeur):

"""
Empile un nouvel élément en mon sommet.
"""
self._tableau.append(valeur)

def dépiler(self):
"""
Dépile et renvoie la valeur de l'élément placé en mon
sommet.

Déclenche une erreur si je suis vide.

"""
if self.est_vide():
raise IndexError("Dépiler sur une pile vide")
else:
return self._tableau.pop()

def consulter(self):
"""
Renvoie la valeur de l'élément placé en mon
sommet.

Déclenche une erreur si je suis vide.

"""
if self.est_vide():
raise IndexError("Dépiler sur une pile vide")
else:
return self._tableau[self.taille() - 1]

def vider(self):
"""
Enlève tous les éléments empiles.
"""
 self._tableau = []

def __str__(self):
N = self.taille()

chaîne = "("

i = 0
while i < N:
chaîne += str(self._tableau[i])
if i == N - 2:
chaîne += " | "
elif i < N - 2:
chaîne += " "
i += 1

chaîne += ")"

return chaîne

def __repr__(self):
return str(self)

FILES

class File1:
"""
Je représente une file, implémentée grâce aux listes python.
"""

def __init__(self):
"""
Crée une file vide
"""
self._tableau = []

def est_vide(self):
"""
Renvoie True ssi je suis une file vide.
"""
return len(self._tableau) == 0

def taille(self):
"""
Renvoie ma taille (en nombre d'éléments emfilés)
"""
return len(self._tableau)

def enfiler(self, valeur):

"""
Enfile un nouvel élément.
"""
self._tableau.append(valeur)

def défiler(self):
"""
Défile et renvoie la valeur de l'élément placé premier
dans la file (le plus ancien).

Déclenche une erreur si je suis vide.

 """
if self.est_vide():
raise IndexError("Défiler sur une file vide")
else:
return self._tableau.pop(0)

def consulter(self):
"""
Renvoie la valeur de l'élément placé en position
de défilement (la valeur la plus ancienne).

Déclenche une erreur si je suis vide.

"""
if self.est_vide():
raise IndexError("Défiler sur une file vide")
else:
return self._tableau[0]

def vider(self):
"""
Enlève tous les éléments empiles.
"""
self._tableau = []

def __str__(self):
N = self.taille()

chaîne = "("

i = 0
while i < N:
chaîne += str(self._tableau[i])
if i < N - 1:
chaîne += " ← "
i += 1

chaîne += ")"

return chaîne

def __repr__(self):
return str(self)

Une implémentation plus efficace à l’aide des listes chaînées

from listes import cellule, tête, queue, liste_vide, est_vide

class Pile2:
"""
Je représente une pile, implémentée grâce à une
liste chaînée immuable.
"""

def __init__(self):
"""
Crée une pile vide
"""
self._liste = liste_vide()
self._taille = 0

def est_vide(self):
"""
Renvoie True ssi je suis une pile vide.
 """
return est_vide(self._liste)

def taille(self):
"""
Renvoie ma taille (en nombre d'éléments empilés)
"""
return self._taille

def empiler(self, valeur):

"""
Empile un nouvel élément en mon sommet.
"""
self._liste = cellule(valeur, self._liste)
self._taille += 1

def dépiler(self):
"""
Dépile et renvoie la valeur de l'élément placé en mon
sommet.

Déclenche une erreur si je suis vide.

"""
if self.est_vide():
raise IndexError("Dépiler sur une pile vide")
else:
valeur = tête(self._liste)
self._liste = queue(self._liste)
self._taille -= 1
return valeur

def consulter(self):
"""
Renvoie la valeur de l'élément placé en mon
sommet.

Déclenche une erreur si je suis vide.

"""
if self.est_vide():
raise IndexError("Dépiler sur une pile vide")
else:
return tête(self._liste)

def vider(self):
"""
Enlève tous les éléments empiles.
"""
self._liste = liste_vide()
self._taille = 0

def __str__(self):
chaîne = "("

position = self._liste
premier = True
while not est_vide(position):
chaîne += str(tête(position))
if premier:
chaîne += " | "
premier = False
elif not est_vide(queue(position)):
chaîne += " "

position = queue(position)
 chaîne += ")"

return chaîne

def __repr__(self):
return str(self)

Une implémentation plus efficace à l’aide d’une liste chaînée variable

from listes import (cellule_variable,

tête, queue,
liste_vide, est_vide,
change_queue)

class File2:
"""
Je représente une file, implémentée grâce à une liste
chaînée variable.
"""

def __init__(self):
"""
Crée une file vide
"""
self._première = liste_vide()
self._dernière = self._première
self._taille = 0

def est_vide(self):
"""
Renvoie True ssi je suis une file vide.
"""
return est_vide(self._première)

def taille(self):
"""
Renvoie ma taille (en nombre d'éléments empilés)
"""
return self._taille

def enfiler(self, valeur):

"""
Enfile un nouvel élément.
"""

# On ajoute le nouvel élément à l'arrière de la liste:

# C'est à ça que sert l'attribut self._dernière

nouvelle_cellule = cellule_variable(valeur, liste_vide())

if est_vide(self._dernière):
# cas particulier: première valeur.
self._dernière = nouvelle_cellule
self._première = self._dernière
else:
# On ajoute la nouvelle cellule en bout de liste,
# mais on ne touche pas à la première cellule qui
# n'est pas ici modifiée par cette opération.
change_queue(self._dernière, nouvelle_cellule)

# Il ne faut pas oublier d'actualiser le pointeur

 # vers la dernière cellule, qui vient juste de
# changer.
self._dernière = nouvelle_cellule

self._taille += 1

def défiler(self):
"""
Défile et renvoie la valeur de l'élément placé premier
dans la file (le plus ancien).

Déclenche une erreur si je suis vide.

"""
if self.est_vide():
raise IndexError("Défiler sur une file vide")
else:
valeur = tête(self._première)
self._première = queue(self._première)
self._taille -= 1

if est_vide(self._première):
# On vient de retirer la dernière cellule
self._dernière = self._première

return valeur

def consulte(self):
"""
Renvoie la valeur de l'élément placé en position
de défilement (la valeur la plus ancienne).

Déclenche une erreur si je suis vide.

"""
if self.est_vide():
raise IndexError("Défiler sur une file vide")
else:
return tête(self._première)

def vider(self):
"""
Enlève tous les éléments empiles.
"""
self._première = liste_vide()
self._dernière = self._première
self._taille = 0

def __str__(self):
chaîne = "("

position = self._première
while not est_vide(position):
chaîne += str(tête(position))
if not est_vide(queue(position)):
chaîne += " ← "
position = queue(position)

chaîne += ")"

return chaîne

def __repr__(self):
return str(self)
plus de détails sur :

https://infoforall.fr/python/python-act180.html