Structures de données IFT-10541

Présentation au sujet: "Structures de données IFT-10541"— Transcription de la présentation:

1 Structures de données IFT-10541
Abder Alikacem Les piles Édition Septembre 2009 Département d’informatique et de génie logiciel

2 Plan Introduction et exemples d’application
Description en terme de type abstrait Implantation

3 Piles Piles : LIFO : last in, first out
DAPS : dernier arrivé, premier sorti ex. : assiettes livres factures pile d’exécution évaluation d’expressions in out pile

4 Files Files : FIFO : first in, first out
PAPS : premier arrivé, premier sorti ex. : assiettes factures banque chaîne de montage imprimante tâches à exécuter out in file

5 Piles et files Structures de données auxiliaires
car utilisées par d’autres structures (comme les listes ordonnées) Utilité : support à des applications support à d’autres structures de données modélisation de la réalité en informatique : système d’exploitation      gestion interne      évaluation d ’expressions      etc.

6 Piles Spécification Spécification physique liste chaînée
Une pile est une structure de données abstraite contenant des éléments homogènes (de type non précisé) à 1 point d’accès et permettant d’ajouter une valeur à la pile (empiler ou push); de lire la dernière valeur ajoutée ; d’enlever la dernière valeur ajoutée (dépiler ou pop); de tester si la pile est vide. On ne « connait » donc de la pile que le dernier élément empilé (son sommet). Spécification physique liste chaînée ou tableau statique ou dynamique

7 Piles espace de mémorisation temporaire, avec conventions de manipulation (gestion) : pile

8 Piles espace de mémorisation temporaire, avec conventions de manipulation (gestion) : ajouter un nouvel élément sur la pile (empiler) in pile

9 Piles espace de mémorisation temporaire, avec conventions de manipulation (gestion) : ajouter un nouvel élément sur la pile (empiler) pile

10 Piles espace de mémorisation temporaire, avec conventions de manipulation (gestion) : ajouter un nouvel élément sur la pile (empiler) enlever un élément de la pile (dépiler) out pile

11 Piles espace de mémorisation temporaire, avec conventions de manipulation (gestion) : ajouter un nouvel élément sur la pile (empiler) enlever un élément de la pile (dépiler) out pile

12 Piles espace de mémorisation temporaire, avec conventions de manipulation (gestion) : ajouter un nouvel élément sur la pile (empiler) enlever un élément de la pile (dépiler) consulter le premier élément de la pile pile

13 Piles espace de mémorisation temporaire, avec conventions de manipulation (gestion) : ajouter un nouvel élément sur la pile (empiler) enlever un élément de la pile (dépiler) consulter le premier élément de la pile pile

14 Piles espace de mémorisation temporaire, avec conventions de manipulation (gestion) : ajouter un nouvel élément sur la pile (empiler) enlever un élément de la pile (dépiler) regarder le premier élément de la pile indiquer si la pile est vide pile

15 Piles espace de mémorisation temporaire, avec conventions de manipulation (gestion) : ajouter un nouvel élément sur la pile (empiler) enlever un élément de la pile (dépiler) regarder le premier élément de la pile indiquer si la pile est vide vérifier si un élément est sur la pile ? pile

16 Piles espace de mémorisation temporaire, avec conventions de manipulation (gestion) : ajouter un nouvel élément sur la pile (empiler) enlever un élément de la pile (dépiler) regarder le premier élément de la pile indiquer si la pile est vide vérifier si un élément est sur la pile ? pile

17 Piles espace de mémorisation temporaire, avec conventions de manipulation (gestion) : ajouter un nouvel élément sur la pile (empiler) enlever un élément de la pile (dépiler) regarder le premier élément de la pile indiquer si la pile est vide vérifier si un élément est sur la pile ? pile

18 Piles espace de mémorisation temporaire, avec conventions de manipulation (gestion) : ajouter un nouvel élément sur la pile (empiler) enlever un élément de la pile (dépiler) regarder le premier élément de la pile indiquer si la pile est vide vérifier si un élément est sur la pile ? ! pile

19 Piles espace de mémorisation temporaire, avec conventions de manipulation (gestion) : ajouter un nouvel élément sur la pile (empiler) enlever un élément de la pile (dépiler) regarder le premier élément de la pile indiquer si la pile est vide regarder si un élément est sur la pile remplacer un élément sur la pile pile

20 Piles espace de mémorisation temporaire, avec conventions de manipulation (gestion) : ajouter un nouvel élément sur la pile (empiler) enlever un élément de la pile (dépiler) regarder le premier élément de la pile indiquer si la pile est vide regarder si un élément est sur la pile remplacer un élément sur la pile pile

21 Piles espace de mémorisation temporaire, avec conventions de manipulation (gestion) : ajouter un nouvel élément sur la pile (empiler) enlever un élément de la pile (dépiler) regarder le premier élément de la pile indiquer si la pile est vide regarder si un élément est sur la pile remplacer un élément sur la pile  les noms anglais pour ces opération sont: PUSH—EMPILER, POP—DÉPILER, TOP—SOMMET, PEEP—EXAMINER et CHANGE—CHANGER. pile

22 Piles Préoccupation de la programmation par objet
initialiser une pile (constructeurs); détruire une pile de ses éléments (destructeur); Constructeur de copie; Surcharge de l’opérateur = pile

23 Piles Vue externe La pile est une structure monolithique, c.-à-d. qu'une pile n'est pas construite à l'aide de sous-piles. Pour cette raison les opérations de Mise à jour ne vont pas créer de nouvel objet Pile mais uniquement modifier l'état de la pile qui reçoit le message.

24 Pile = liste + gestion adaptée
manipulations (empiler et dépiler) par le même point d’accès out out in in pile pile

25 Pile = liste + gestion adaptée
empiler (push) :

26 Pile = liste + gestion adaptée
empiler (push) : L  L +1 x (ou : L  L +|L|+1 x)

27 Pile = liste + gestion adaptée
empiler (push) : L  L +1 x (ou : L  L +|L|+1 x) dépiler (pop) :

28 Pile = liste + gestion adaptée
empiler (push) : L  L +1 x (ou : L  L +|L|+1 x) dépiler (pop) : L  -1L (ou : L  -|L|L)

29 Pile = liste + gestion adaptée
empiler (push) : L  L +1 x (ou : L  L +|L|+1 x) dépiler (pop) : L  -1L (ou : L  -|L|L) sommet (top) :

30 Pile = liste + gestion adaptée
empiler (push) : L  L +1 x (ou : L  L +|L|+1 x) dépiler (pop) : L  -1L (ou : L  -|L|L) sommet (top) : L1 (ou : L|L|)

31 Pile = liste + gestion adaptée
empiler (push) : L  L +1 x (ou : L  L +|L|+1 x) dépiler (pop) : L  -1L (ou : L  -|L|L) sommet (top) : L1 (ou : L|L|) pile vide ?

32 Pile = liste + gestion adaptée
empiler (push) : L  L +1 x (ou : L  L +|L|+1 x) dépiler (pop) : L  -1L (ou : L  -|L|L) sommet (top) : L1 (ou : L|L|) pile vide ? L = ?

33 Pile = liste + gestion adaptée
empiler (push) : L  L +1 x (ou : L  L +|L|+1 x) dépiler (pop) : L  -1L (ou : L  -|L|L) sommet (top) : L1 (ou : L|L|) pile vide ? L = ? élément sur la pile (peep) ?

34 Pile = liste + gestion adaptée
empiler (push) : L  L +1 x (ou : L  L +|L|+1 x) dépiler (pop) : L  -1L (ou : L  -|L|L) sommet (top) : L1 (ou : L|L|) pile vide ? L = ? élément sur la pile (peep) ? x  L?

35 Pile = liste + gestion adaptée
empiler (push) : L  L +1 x (ou : L  L +|L|+1 x) dépiler (pop) : L  -1L (ou : L  -|L|L) sommet (top) : L1 (ou : L|L|) pile vide ? L = ? élément sur la pile (peep) ? x  L? remplacer un élément sur la pile

36 Pile = liste + gestion adaptée
empiler (push) : L  L +1 x (ou : L  L +|L|+1 x) dépiler (pop) : L  -1L (ou : L  -|L|L) sommet (top) : L1 (ou : L|L|) pile vide ? L = ? élément sur la pile (peep) ? x  L? remplacer un élément sur la pile x = L?; L  -?L; L  L +? y

37 Piles : spécifications de l’interface
empiler : p  p + x prototype : void empiler(TypeEl x); /** * \brief Empiler un élément dans la pile * * \pre Il y a assez de mémoire pour empiler x * \post La pile comprend un élément de plus * \post La pile est inchangée sinon * \exception bad_alloc si pas assez de mémoire */

38 Piles : spécifications de l’interface
dépiler : -p prototype : void depiler(); /** * \brief Dépiler la pile * * \pre La pile a au moins un élément * \post La pile comprend un élément de moins * \post La pile est inchangée sinon * \exception logic_error si la pile est vide */

39 Piles : spécifications de l’interface
sommet : !p prototype : TypeEl sommet(); /** * \brief Consulter le sommet de la pile * * \pre La pile a au moins un élément * \post La pile est inchangée * \post Une copie de l’élément au sommet est retournée * \exception logic_error si la pile est vide */

40 Piles : spécifications de l’interface
pile vide : p = ? prototype : bool estVide(); /** * \brief Vérifier si la pile est vide * * \post La pile est inchangée * \post VRAI ou FAUX est retourné selon que la pile est vide ou non */

41 Piles : spécifications de l’interface
appartenance : x  p? prototype : bool appartient(TypeEl x); /** * \brief Vérifier si un élément appartient à la pile * * \post La pile est inchangée * \post VRAI ou FAUX est retourné selon que x  à la pile ou non */

42 Piles : spécifications de l’interface
remplacement : p  p - x/y prototype : void remplacer(TypeEl x, TypeEl y); /** * \brief Remplacer un élément dans la pile * * \pre x appartient à la pile *\post Le premier x trouvé (en débutant au sommet) est remplacé par y *\post La pile est inchangée sinon *\exception logic_error si pas dans la pile */

43 La classe Pile template <typename T> class Pile { private:
//...Modèle d’implantation public: // constructeurs et destructeurs Pile(); //constructeur Pile(const Pile&) throw(bad_alloc); //constructeur copie ~Pile(); //destructeur // Modificateurs void empiler(T) throw (bad_alloc); T depiler()throw(logic_error); //Sélecteurs bool estVide(){ return sommet == 0;} int taille() { return cpt;} T& sommet() throw (logic_error); // élément au sommet //surcharge d'opérateurs Pile<T>& operator = (const Pile<T>&) throw (bad_alloc); friend ostream& operator << (ostream& , const Pile& ); };

44 Piles : modèles d’implantation
en tableau : (accès : indice 0) 1 2 3 4 ... 99 pile

45 Piles : modèles d’implantation
en tableau : (accès : indice 0) 1 2 3 4 ... 99 pile

46 Piles : modèles d’implantation
en tableau : (accès : indice 0) 1 2 3 4 ... 99 pile

47 Piles : modèles d’implantation
en tableau : (accès : indice 0) 1 2 3 4 ... 99 pile

48 Piles : modèles d’implantation
en tableau : (accès : indice 0) 1 2 3 4 ... 99 pile

49 Piles : modèles d’implantation
en tableau : (accès : indice 0) 1 2 3 4 ... 99 pile

50 Piles : modèles d’implantation
en tableau : (accès : indice 0) 1 2 3 4 ... 99 pile

51 Piles : modèles d’implantation
en tableau : (accès : indice 0) 1 2 3 4 ... 99 pile

52 Piles : modèles d’implantation
en tableau : (accès : indice 0) 1 2 3 4 ... 99 pile

53 Piles : modèles d’implantation
en tableau : (accès : indice 0) 1 2 3 4 ... 99 pile

54 Piles : modèles d’implantation
en tableau : (accès : indice 0) 1 2 3 4 ... 99 pile

55 Piles : modèles d’implantation
en tableau : (accès : indice 0) 1 2 3 4 ... 99 pile

56 Piles : modèles d’implantation
en tableau : (accès : indice 0) 1 2 3 4 ... 99 pile

57 Piles : modèles d’implantation
en tableau : (accès : indice 0) 1 2 3 4 ... 99 pile

58 Piles : modèles d’implantation
en tableau : (accès : indice 0) 1 2 3 4 ... 99 pile

59 Piles : modèles d’implantation
en tableau : (accès : indice 0) 1 2 3 4 ... 99 pile

60 Piles : modèles d’implantation
en tableau : (accès : indice 0) 1 2 3 4 ... 99 pile

61 Piles : modèles d’implantation
en tableau : (accès : indice 0) 1 2 3 4 ... 99 pile

62 Piles : modèles d’implantation
en tableau : (accès : indice 0) 1 2 3 4 ... 99 pile

63 Piles : modèles d’implantation
en tableau : (accès : indice 0) 1 2 3 4 ... 99 pile

64 Piles : modèles d’implantation
en tableau : (accès : indice 0) 1 2 3 4 ... 99 pile

65 Piles : modèles d’implantation
en tableau : (accès : indice 0) 1 2 3 4 ... 99 pile

66 Piles : modèles d’implantation
en tableau : (accès par la fin) 1 2 3 4 ... 99 pile

67 Piles : modèles d’implantation
en tableau : (accès par la fin) 1 2 3 4 ... 99 pile

68 Piles : modèles d’implantation
en tableau : (accès par la fin) 1 2 3 4 ... 99 pile

69 Piles : modèles d’implantation
en tableau : (accès par la fin) 1 2 3 4 ... 99 pile

70 Piles : modèles d’implantation
en tableau : (accès par la fin) 1 2 3 4 ... 99 pile

71 Piles : modèles d’implantation
en tableau : (accès par la fin) 1 2 3 4 ... 99 pile

72 Piles : modèles d’implantation
en tableau : (accès par la fin) 1 2 3 4 ... 99 pile

73 Piles : modèles d’implantation
en tableau : (accès par la fin) 1 2 3 4 ... 99 pile

74 Piles : modèles d’implantation
en tableau : (accès par la fin) 1 2 3 4 ... 99 pile

75 Piles : modèles d’implantation
en tableau : (accès par la fin) 1 2 3 4 ... 99 pile

76 Piles : modèles d’implantation
en tableau : (accès par la fin) 1 2 3 4 ... 99 pile

77 Piles : modèles d’implantation
en tableau : (accès par la fin) 1 2 3 4 ... 99 pile

78 Piles : modèles d’implantation
en tableau : (accès par la fin) 1 2 3 4 ... 99 pile

79 Piles : implantation dans un tableau
Implantation dans un tableau dynamique { private : T* tab; int sommet; int tailleMax; public: … Tableau tab réservé dans le tas Constructeur avec un paramètre : taille maximum ==> bonne implantation si on peut évaluer la taille maximum à l’utilisation de la pile

80 Piles : implantation dans un tableau
Implantation dans un tableau dynamique template <typename T, in MAX = 100 > class Pile { private : T* tab; int sommet; int tailleMax; public: Pile(const int max = MAX) throw (bad_alloc); // constructeur : init taille maxi ... ~Pile (void); // destructeur };

81 Piles : implantation dans un tableau
Constructeur template <Typename T> Pile<T> :: Pile (int max) throw (bad_alloc){ tab = new T [max]; sommet = -1; maxTaille =max; } Destructeur template <class T> Pile<T> :: ~Pile (void) { if (tab!=0) delete [ ] tab; }

82 Piles : implantation dans un tableau
dépiler template <typename T> T Pile<T> :: depiler(void) throw (logic_error){ if (!estVide()) return tab[sommet--]; else throw logic_error("Depiler: la pile est vide!"); } Sélecteur : vide template <typename T> bool Pile<T> :: estVide (void){ return (sommet == -1); }

83 Piles : implantation dans un tableau
template <typename T> void Pile<T> :: empiler(const T& e) throw (length_error){ if (sommet+1 < maxTaille) { sommet += 1; tab[sommet] = e; } else { throw length_error("Empiler:la pile est pleine\n"); } empiler Remarque : on suppose que l ’opérateur d ’affectation existe ou est surchargé dans la classe qui correspond au paramètre T. => intérêt de la surcharge des opérateurs

84 Piles : implantation dans un tableau
Remarque Il faut cependant noter que la contrainte de pile pleine n’est pas une contrainte liée à la structure de donnée pile. Théoriquement, il n’y a pas de limite sur le nombre d’éléments d’une pile. En pratique, son implantation dans un tableau limite le nombre d’éléments à maxTaille.

85 Piles : implantation dans un tableau
Surcharge de l’op. = template <typename T> Pile<T>& Pile<T> :: operator = (const Pile<T>& p) { if (tab!=0) delete [ ] tab; //on nettoie this tab=new T [p.maxTaille]; maxTaille=p.maxTaille; for (int i=0; i<maxTaille;i+=1) tab[i]=p.tab[i]; sommet=p.pommet; return (*this); //retourner : une référence sur l ’objet courant }

86 Piles : implantation dans un tableau
Constructeur de copie template <typename T> Pile<T> :: Pile (const Pile<T>& p) { tab=new X [p.maxtaille]; maxTaille=p.maxTaille; for (int i=0; i<maxTaille;i+=1) tab[i]=p.tab[i]; sommet=p.sommet; }

87 Piles : modèles d’implantation
liste chaînée debut pile

88 Piles : modèles d’implantation
liste chaînée : empiler el debut suivant pile

89 Piles : modèles d’implantation
liste chaînée : empiler el el debut suivant suivant pile

90 Piles : modèles d’implantation
liste chaînée : empiler el el debut suivant suivant pile

91 Piles : modèles d’implantation
liste chaînée : empiler el el el debut suivant suivant suivant pile

92 Piles : modèles d’implantation
liste chaînée : empiler el el el debut suivant suivant suivant pile

93 Piles : modèles d’implantation
liste chaînée : dépiler el el el debut suivant suivant suivant pile

94 Piles : modèles d’implantation
liste chaînée : dépiler x el el el debut suivant suivant suivant pile

95 Piles : modèles d’implantation
liste chaînée : dépiler el el debut suivant suivant pile

96 Piles : modèles d’implantation
liste chaînée : dépiler x el el debut suivant suivant pile

97 Piles : modèles d’implantation
liste chaînée : dépiler el debut suivant pile

98 Piles : modèles d’implantation
liste chaînée : dépiler x el debut suivant pile

99 Piles : modèles d’implantation
liste chaînée : dépiler debut pile

100 Piles : implantation dans une liste chaînée
Version 1 template <typename T> class Noeud{ public: Noeud (const T& data_item, Noeud * next_ptr = 0) : el(data_item), suivant(next_ptr) {}//constructeur ~Noeud () {}; //destructeur qui ne fait rien }; friend class Pile <T>; private : T el; Noeud<T> * suivant;

101 Piles : implantation dans une liste chaînée
template <typename T> class Pile { public: Pile (); // Constructeur Pile (const pile<X>&) throw (bad_alloc); // Constructeur par copie ~Pile (); // Destructeur Pile<T>& operator=(const Pile<T>& P); // P1 = P void empiler (const T& a) throw (bad_alloc); T depiler () throw (logic_error); T& sommet (void) throw (logic_error); // sélecteur : valeur //placée au sommet bool vide(); //sélecteur : ( IC est vide?) }; Version 1 private : Noeud<T>* sommet; // pointeur sur la cellule sommet int cpt; // Nombre d'élements de la pile void detruire (); //Méthode privée utile pour le destructeur // et l’op. =

102 Piles : implantation dans une liste chaînée
template <typename T> class Pile { public: Pile (); Pile (const Pile<T>&) throw (bad_alloc); ~Pile (); Pile<T>& operator=(const Pile<T>& P); //.. private: class Noeud{ public: T el; Noeud * suivant; Noeud (const T& data_item, Noeud * next_ptr = 0) : el(data_item), suivant(next_ptr) {} }; typedef Noeud * elem; elem sommet; int cpt; void detruire (); Version 2

103 Piles : implantation dans une liste chaînée
destructeur constructeur template <class X> Pile<X>:: ~Pile(void) { if (sommet != 0) detruire( );} template <typename T> Pile<T>::Pile (void) { sommet =0; cpt = 0; } template <typename T> void Pile<T>::detruire () { Noeud<T>* p; while (sommet != 0){ p=sommet->suivant; delete sommet; sommet=p; }

104 Piles : implantation dans une liste chaînée
template <typename T> void Pile<T>::detruire () { … delete (sommet); } Autre version Pour que l ’espace occupé par les composants pointés dans chaque nœud soit libéré lorsque la fonction détruire est appliquée, autre version, il faut un destructeur de noeud qui ait cet effet : Chaque fois que l’instruction delete est appliquée sur un pointeur de cellule, alors le destructeur de la classe Noeud est activé. template <typename T> Noeud<T>:: ~Noeud (void){ if (sommet!=0) delete sommet; } Libère l ’espace occupé par le composant pointé par ptr

105 Les piles Comparaison des 2 implantations
Toutes les implantations des opérations d’une pile utilisant un tableau ou une liste chaînée prennent un temps constant i.e. en O(1). Par conséquent, d’un point de vue d’efficacité, aucune des deux implantations n’est mieux que l’autre. D’un point de vue de complexité spatiale, le tableau doit déclarer une taille fixe initialement. Une partie de cet espace est perdue quand la pile n’est pas bien remplie. La liste peut augmenter ou rapetisser au besoin mais demande un extra espace pour mémoriser les adresses des pointeurs.

106 Exemples d’utilisation des piles
Le problème des parenthèses : étant donnée une expression avec des parenthèses, est-elle bien ou mal parenthésée ? ((a + b) c − (d + 4) (5 + (a + c))) (c + (d + (e + 5 g) f) a) (correct) (a + b)( (incorrect) Encore un peu plus complexe : différentes parenthèses. Exemple avec [ et ( ([])[()(()[])] : correct ([)] : incorrect

107 Vérification de parenthèsage
Tant que lire caractère c Si c est ( ou [ empiler c Sinon Si c est ) ou ] Si pile vide ÉCHEC c′ = lire la pile Si c et c′ correspondent dépiler OK

108 Code C++ bool check(string s) { Pile p;
for (unsigned int i(0); i < s.size(); ++i) { if ((s[i] == ’(’) || (s[i] == ’[’)) p.empile(s[i]); else if (s[i] == ’)’) { if ((!p.est_vide()) && (p.top() == ’(’)) p.depile(); else return false; } else if (s[i] == ’]’) { if ((!p.est_vide()) && (p.top() == ’[’)) } return p.est_vide();

109 Exemples d’application des piles
Reconnaissance syntaxique : Soit une chaîne de caractères définie par la règle suivante : Une chaîne quelconque S suivie du caractère *, suivi de la chaîne S inversée. Exemple abc*cba La chaîne peut contenir n’importe quel caractère alphanumérique. La chaîne se termine par le marqueur fin de ligne. Conception : Pour déterminer si la chaîne est légale, il faut : 1) Lire jusqu’à ‘*’ les caractère un à un en les empilant dans une pile. 2) Après ‘*’, jusqu’à la fin de la chaîne, lire un caractère, dépiler le caractère au sommet de la pile et comparer les deux, s’il ne sont pas égaux, la chaîne est invalide. 3) Si tous les caractères sont égaux et que la pile s’est vidée, la chaîne est valide.

110 Exemples d’application des piles
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. La notation postfixée (polonaise) consiste à placer les opérandes devant l'opérateur. La notation infixée (parenthèsée) consiste à entourer les opérateurs par leurs opérandes. Les parenthèses sont nécessaires uniquement en notation infixée. Certaines règles permettent d'en réduire le nombre (priorité de la multiplication par rapport à l'addition, en cas d'opérations unaires représentées par un caractère spécial (-, !,...). Les notations préfixée et postfixée sont d'un emploi plus facile puisqu'on sait immédiatement combien d'opérandes il faut rechercher.

111 Exemples d’application des piles
Calcul arithmétique : Détaillons ici la saisie et l'évaluation d'une expression Postfixée. La notation usuelle, comme (3 + 5) * 2, est dite infixée. Son défaut est de nécessiter l'utilisation de parenthèses pour éviter toute ambiguïté (ici, avec 3 + (5 * 2)). Pour éviter le parenthésage, il est possible de transformer une expression infixée en une expression postfixée en faisant "glisser«  les opérateurs arithmétiques à la suite des expressions auxquelles ils s'appliquent. Exemple (3 + 5) * 2 s'écrira en notation postfixée (notation polonaise): * alors que 3 + (5 * 2) s'écrira: * +

112 Exemples d’application des piles
Calcul arithmétique: On voit que la multiplication vient immédiatement après ses deux opérandes A et B. Imaginons maintenant que A * B est calculé et stocké dans T. Alors la division / vient juste après les deux arguments T et C. Forme infixe: A/B ** C + D * E - A * C Forme postfixe: ABC ** /DE * + AC * -

113 Exemples d’application des piles
Algorithme Initialiser la pile à vide; while (ce n’st pas la fin del’expression postfixée) { prendre l’item prochain de postfixe; if(item est une valeur) empiler; else if(item operateur binaire ) { dépiler dans x; dépiler dans y; effectuer y operateur x; empiler le résultat obtenu; } else if (item opérateur unaire) { effectuer opérateur(x); } Evaluation en Postfixe Considérons l’expression en postfixe suivante: * * la seule valeur qui reste dans la pile est le résultat recherché. Opérateur binaires: +, -, *, /, etc., Opérateur unaires: moins unaire, racine carrée, sin, cos, exp, … etc.

114 Exemples d’application des piles
Algorithme initialise la pile et l’output postfixe à vide; while(ce n’est pas la fin de l’expression infixe) { prendre le prochain item infixe if (item est une valeur) concaténer item à postfixe else if (item == ‘(‘) empiler item else if (item == ‘)’) { dépiler sur x while(x != ‘(‘) concaténer x à postfixe & dépiler sur x } else { while(precedence(stack top) >= precedence(item)) dépiler sur x et concaténer x à postfixe; empiler item; while (pile non vide) Infixe à Postfixe Bien entendu la notation postfixe ne sera pas d’une grande utilité s’il n’existait pas un algorithme simple pour convertir une expression infixe en une expression postfixe. Encore une fois, cet algorithme utilise une pile.

115 Exemples d’application des piles
Algorithme initialise la pile et l’output postfixe à vide; while(ce n’est pas la fin de l’expression infixe) { prendre le prochain item infixe if (item est une valeur) concaténer item à postfixe else if (item == ‘(‘) empiler item else if (item == ‘)’) { dépiler sur x while(x != ‘(‘) concaténer x à postfixe & dépiler sur x } else { while(precedence(stack top) >= precedence(item)) dépiler sur x et concaténer x à postfixe; empiler item; while (pile non vide) Infixe à Postfixe Précédence des opérateurs 4 : ‘(‘ – déplée seulement si une ‘)’ est trouvée 3 : tous les opérateurs unaires 2 : / * 1 : + - L’algorithme passe les opérandes à la forme postfixe, mais sauvegarde les opérateurs dans la pile jusqu’à ce que tous les opérandes soient tous traduits.