Informatique – 2ème Année IPEIN 2021/2022

TD1 : Structures de Données « Piles & Files »

Exercice 1 :
Reprendre le module « op_file.py » en essayant de fixer une taille maximale de la file par
l’introduction d’une constante NMAX=40. Prévoir les traitements nécessaires au bon
fonctionnement du module en cas de saturation de la file.

Exercice 2 :
Une pile est une structure de données de type LIFO (Last In First Out) : le dernier entré est le
premier sorti. On suppose qu’on a les opérations suivantes dans le fichier « op_pile.py » :
- creer_pile() : création et renvoi de la pile « p »
- est_vide(p) : renvoie « True » si la pile est vide, « False » sinon.
- sommet(p) : renvoie l’élément sommet de la pile.
- depiler(p) : supprime de la pile le sommet.
- empiler(p,elt) : ajoute au sommet de la pile l’élément « elt ».
Écrivez les fonctions suivantes.
1) afficher(p) : cette fonction affiche tous les éléments de la pile.
2) depilerKelt(p,k) : cette méthode dépile « k » éléments si la pile contient au moins
« k » éléments, sinon elle dépile toute la pile.
3) depilerJusqua(p,elt) : cette fonction dépile la pile jusqu’à l’élément « elt » et l’élément
« elt » n’est pas dépilé. Si l’élément n’appartient pas à la pile, alors la méthode dépile
toute la pile.
Exercice 3 :
Une file est une structure de données de type FIFO (First In First Out) : le premier entré est le
premier sorti. On suppose qu’on a les primitives suivantes dans le fichier « op_file.py »:
- creer_file(f) : création et renvoi de la file « f ».
- est_vide(f) : renvoie « True » si la file est vide, « False » sinon.
- sommet(f) : renvoie le premier élément de la file.
- defiler(f) : supprime de la file le premier élément.
- enfiler(f,elt) : ajoute dans la file l’élément elt.
Écrivez les fonctions suivantes.
1) afficher(f) : cette fonction affiche tous les éléments de la file.
2) defilerJusqua(f,elt) : cette méthode défile la file jusqu’à l’élément « elt ». L’élément
« elt » n’est pas défilé. Si l’élément n’appartient pas à la file, alors la méthode défile
tous les éléments de la file.
Exercice 4 :
Écrivez les méthodes suivantes. On pourra éventuellement utiliser une ou des piles/files
temporaires, on utilisera les primitives créer_pile() qui renvoie une pile vide et créer_file() qui
renvoie une file vide.
1. appartient(p,elt) : cette fonction s’applique sur une Pile renvoie « vrai » si l’élément
appartient à la pile, « faux » sinon.
Attention : il est important que la pile ne change pas.
2. Inverser_file(f) : cette fonction inverse les éléments de la file à laquelle elle est
appliquée. On a le droit d’utiliser des files ou des piles temporaires.
3. Inverser_pile(p) : cette fonction inverse les éléments de la pile à laquelle elle est
appliquée. On interdit l’utilisation de files. Seules des piles temporaires peuvent être
utilisées.

TD1 : Corrigé https://www.facebook.com/groups/ipein.info Page 1 sur 1

Informatique – 2ème Année IPEIN 2021/2022

TD1 : Structures de Données « Piles & Files »

CORRIGE
Exercice1 :
1. #Fichier op_file_max.py
2. """Files non bornées à nmax éléments."""
3. nmax = 40
4. #creation d'une file vide
5. def creer_file():
6. return []
7.
8. #test de saturation de la file
9. def est_sature(f):
10. return len(f) == nmax
11.
12. #ajouter un element dans la file
13. #comme insérer, place l’élément à la fin de la file F (enqueue en anglais)
14. def enfiler(f,v):
15. if not sature(f):
16. f.insert(0,v)
17.
18. #suppression d'un element
19. #comme supprimer, retire de la file le premier (dequeue en anglais)
20. def defiler(f):
21. if not est_vide(f):
22. returnf.pop()
23.
24. #***** sommet de la file *****
25. #renvoie le premier élément ajouté et non encore retiré :
26. #le début ou le premier ou la tête de file (queue front en anglais)
27. def sommet(f):
28. assert len(f) > 0
29. return f[len(f)-1]
30. #***** sentinelle de la file *****
31. #renvoie le dernier élément ajouté et non encore retiré :
32. #la fin ou le dernier ou la queue de file (queue back en anglais)
33. def queue(f): #sentienelle de la file
34. if not est_vide(f):
35. return f[0]
36.
37. #nombre d'element dans f
38. def taille(f):
39. returnlen(f)
40.
41. #test si la file est vide
42. #Renvoie vrai si la file est vide et faux sinon (empty)
43. def est_vide(f):
44. return taille(f) == 0

Exercice2 :
1. from op_pile import *
2. #1) fonction afficher(f)

TD1 : Corrigé https://www.facebook.com/groups/ipein.info Page 1 sur 3

Informatique – 2ème Année IPEIN 2021/2022
3. #version1, qui vide la pile en affichant ses éléments
4. def afficher1(p):
5. while not est_vide(p):
6. print(depiler(p))
7.
8. #Version 2, qui laisse la pile intacte tout en utilisant
9. #les fonctions fournies uniquement
10. def afficher2(p) :
11. temp = creer_pile()
12. while not est_vide(p):
13. elt = depiler(p)
14. print(elt)
15. empiler(temp,elt)
16. while not est_vide(temp):
17. empiler(p,depiler(temp))
18.
19. #Version 3, qui laisse la pile intacte tout en utilisant
20. #les fonctions fournies uniquement
21. def afficher3(p) :
22. L = []
23. while not est_vide(p):
24. elt = depiler(p)
25. print(elt)
26. L.append(elt)
27. for i in range(len(L)-1,-1,) :
28. empiler(p,L[i])
29.
30. #Version 4, qui laisse la pile intacte, mais là,
31. #il faudra supposer que l'on dispose de détails sur la réalisation
32. #de la pile, qui ne sont pas donnés généralement.
33. #Si, par exemple, la pile est réalisée par une liste,on peut écrire :
34. def afficher4(p) :
35. for i in range(len(p)-1,-1,-1):
36. print(p[i])
37.
38. #2) depilerKelt(p,k) : cette méthode dépile « k » éléments si la pile
39. #contient au moins « k » éléments, sinon elle dépile toute la pile.
40. def depilerKelt(p,k):
41. while k>0 and not est_vide(p):
42. print(depiler(p))
43. k -= 1
44.
45. #3)depilerJusqua(p,elt) : cette méthode dépile jusqu’à l’élément « elt ».
46. def depilerJusqua(p,elt):
47. while not est_vide(p) and elt != sommet(p):
48. depiler(p)
49.

Exercice3 :
1. from op_file import *
2. #1) afficher() : cette fonction affiche tous les éléments de la file.
3. def afficher(f):
4. temp = creer_file()
5. while not est_vide(f):
6. elt = defiler(f)

TD1 : Corrigé https://www.facebook.com/groups/ipein.info Page 2 sur 3

Informatique – 2ème Année IPEIN 2021/2022
7. print(elt)
8. enfiler(temp,elt)
9. while not est_vide(temp):
10. enfiler(f,defiler(temp))
11.
12. #2)defilerJusqua(f,elt) : cette fonction défile jusqu’à l’élément « elt ».
13. def defilerJusqua(f,elt):
14. while not est_vide(f) and sommet(f) != elt:
15. defiler(f)

Exercice4 :
1. from op_file import *
2. fromop_pile import *
3. #1) la fonction appartient(p,elt)
4. def Appartient(p,elt) :
5. p1 = creer_pile()
6. while not est_vide(p) and sommet(p) != elt:
7. empiler(p1,depiler(p))
8. resultat not est_vide(p)
9. while not est_vide(p1):
10. empiler(p,depiler(p1))
11. return resultat
12.
13. #2) la fonction Inverse(f)
14. importop_pile as pile # pour éviter d’écraser les fonctions de module pile
15. importop_file as file # par celles de file (Exp. est_vide())
16. def Inverser_file(f) :
17. p = pile.creer_pile()
18. while not file.est_vide(f):
19. pile.empiler(p,file.defiler(f))
20. while not pile.est_vide(p):
21. file.enfiler(f,pile.depiler(p))
22.
23. #3) dans ce cas utilisera deux piles auxiliaires, p1 et p2
24. def Inverser_pile1(p) :
25. p1 = creer_pile()
26. while not est_vide(p):
27. empiler(p1,depiler(p))
28. p2 = creer_pile()
29. while not est_vide(p1):
30. empiler(p2,depiler(p1))
31. while not est_vide(p2):
32. empiler(p,depiler(p2))
33.
34. def Inverser_pile2(p) :
35. p1 = creer_pile()
36. while not est_vide(p):
37. empiler(p1,depiler(p))
38. p = p1

TD1 : Corrigé https://www.facebook.com/groups/ipein.info Page 3 sur 3