La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

Structures de données IFT-10541 Abder Alikacem Les piles Département dinformatique et de génie logiciel Édition Septembre 2009.

Présentations similaires


Présentation au sujet: "Structures de données IFT-10541 Abder Alikacem Les piles Département dinformatique et de génie logiciel Édition Septembre 2009."— Transcription de la présentation:

1

2 Structures de données IFT Abder Alikacem Les piles Département dinformatique et de génie logiciel Édition Septembre 2009

3 Plan Introduction et exemples dapplication Description en terme de type abstrait Implantation

4 Piles Piles : LIFO : last in, first out DAPS : dernier arrivé, premier sorti ex. : assiettes livres factures pile dexécution évaluation dexpressions inout pile

5 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 outin file

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

7 Piles Spécification Une pile est une structure de données abstraite contenant des éléments homogènes (de type non précisé) à 1 point daccès et permettant dajouter une valeur à la pile (empiler ou push); de lire la dernière valeur ajoutée ; denlever 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

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

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

10 Piles espace de mémorisation temporaire, avec conventions de manipulation (gestion) : ajouter un nouvel élément sur la pile (empiler) 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) out 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) consulter le premier élément de la pile 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 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 vérifier si un élément est 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 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 Piles

22 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: PUSHEMPILER, POPDÉPILER, TOPSOMMET, PEEPEXAMINER et CHANGECHANGER. pile Piles

23 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 lopérateur = Piles pile

24 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. Piles

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

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

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

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

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

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

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

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

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

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

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

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

37 empiler (push) : L L + 1 x(ou : L L + |L|+1 x) dépiler (pop) : L - 1 L(ou : L - |L| L) sommet (top) : L 1 (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 Pile = liste + gestion adaptée

38 Piles : spécifications de linterface 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 * */

39 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 * */ Piles : spécifications de linterface

40 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 * */ Piles : spécifications de linterface

41 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 * */ Piles : spécifications de linterface

42 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 * */ Piles : spécifications de linterface

43 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 * */ Piles : spécifications de linterface

44 La classe Pile template class Pile { private: //...Modèle dimplantation 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& operator = (const Pile&) throw (bad_alloc); friend ostream& operator << (ostream&, const Pile& ); };

45 Piles : modèles dimplantation en tableau : (accès : indice 0) pile

46 en tableau : (accès : indice 0) pile Piles : modèles dimplantation

47 en tableau : (accès : indice 0) pile Piles : modèles dimplantation

48 en tableau : (accès : indice 0) pile Piles : modèles dimplantation

49 en tableau : (accès : indice 0) pile Piles : modèles dimplantation

50 en tableau : (accès : indice 0) pile Piles : modèles dimplantation

51 en tableau : (accès : indice 0) pile Piles : modèles dimplantation

52 en tableau : (accès : indice 0) pile Piles : modèles dimplantation

53 en tableau : (accès : indice 0) pile Piles : modèles dimplantation

54 en tableau : (accès : indice 0) pile Piles : modèles dimplantation

55 en tableau : (accès : indice 0) pile Piles : modèles dimplantation

56 en tableau : (accès : indice 0) pile Piles : modèles dimplantation

57 en tableau : (accès : indice 0) pile Piles : modèles dimplantation

58 en tableau : (accès : indice 0) pile Piles : modèles dimplantation

59 en tableau : (accès : indice 0) pile Piles : modèles dimplantation

60 en tableau : (accès : indice 0) pile Piles : modèles dimplantation

61 en tableau : (accès : indice 0) pile Piles : modèles dimplantation

62 en tableau : (accès : indice 0) pile Piles : modèles dimplantation

63 en tableau : (accès : indice 0) pile Piles : modèles dimplantation

64 en tableau : (accès : indice 0) pile Piles : modèles dimplantation

65 en tableau : (accès : indice 0) pile Piles : modèles dimplantation

66 en tableau : (accès : indice 0) pile Piles : modèles dimplantation

67 en tableau : (accès par la fin) pile Piles : modèles dimplantation

68 en tableau : (accès par la fin) pile Piles : modèles dimplantation

69 en tableau : (accès par la fin) pile Piles : modèles dimplantation

70 en tableau : (accès par la fin) pile Piles : modèles dimplantation

71 en tableau : (accès par la fin) pile Piles : modèles dimplantation

72 en tableau : (accès par la fin) pile Piles : modèles dimplantation

73 en tableau : (accès par la fin) pile Piles : modèles dimplantation

74 en tableau : (accès par la fin) pile Piles : modèles dimplantation

75 en tableau : (accès par la fin) pile Piles : modèles dimplantation

76 en tableau : (accès par la fin) pile Piles : modèles dimplantation

77 en tableau : (accès par la fin) pile Piles : modèles dimplantation

78 en tableau : (accès par la fin) pile Piles : modèles dimplantation

79 en tableau : (accès par la fin) pile Piles : modèles dimplantation

80 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 à lutilisation de la pile

81 Piles : implantation dans un tableau template 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 }; Implantation dans un tableau dynamique

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

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

84 Piles : implantation dans un tableau template void Pile :: 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

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

86 Piles : implantation dans un tableau template Pile& Pile :: operator = (const Pile& p) { if (tab!=0) delete [ ] tab; //on nettoie this tab=new T [p.maxTaille]; maxTaille=p.maxTaille; for (int i=0; i

87 Piles : implantation dans un tableau template Pile :: Pile (const Pile& p) {tab=new X [p.maxtaille]; maxTaille=p.maxTaille; for (int i=0; i

88 liste chaînée debut pile Piles : modèles dimplantation

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

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

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

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

93 liste chaînée : empiler debut el suivant el suivant el suivant pile Piles : modèles dimplantation

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

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

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

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

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

99 liste chaînée : dépiler debut el suivant pile x Piles : modèles dimplantation

100 liste chaînée : dépiler debut pile Piles : modèles dimplantation

101 Piles : implantation dans une liste chaînée template 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 ; private : T el; Noeud * suivant; Version 1 Implantation dans une liste chaînée

102 Piles : implantation dans une liste chaînée template class Pile { public: Pile ();// Constructeur Pile (const pile&) throw (bad_alloc); // Constructeur par copie ~Pile ();// Destructeur Pile& operator=(const Pile& 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?) }; private : Noeud * 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 lop. = Version 1

103 Piles : implantation dans une liste chaînée template class Pile { public: Pile (); Pile (const Pile &) throw (bad_alloc); ~Pile (); Pile & operator=(const Pile & 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

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

105 Piles : implantation dans une liste chaînée template void Pile ::detruire () { … delete (sommet); } template Noeud :: ~Noeud (void){ if (sommet!=0) delete sommet; } 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 linstruction delete est appliquée sur un pointeur de cellule, alors le destructeur de la classe Noeud est activé. Libère l espace occupé par le composant pointé par ptr Autre version

106 Les piles Comparaison des 2 implantations Toutes les implantations des opérations dune pile utilisant un tableau ou une liste chaînée prennent un temps constant i.e. en O(1). Par conséquent, dun point de vue defficacité, aucune des deux implantations nest mieux que lautre. Dun 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 nest pas bien remplie. La liste peut augmenter ou rapetisser au besoin mais demande un extra espace pour mémoriser les adresses des pointeurs.

107 Exemples dutilisation 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

108 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 Sinon c = lire la pile Si c et c correspondent dépiler Sinon ÉCHEC Si pile vide OK Sinon ÉCHEC

109 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() == [)) p.depile(); else return false; } return p.est_vide(); }

110 Exemples dapplication 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 nimporte 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, sil ne sont pas égaux, la chaîne est invalide. 3) Si tous les caractères sont égaux et que la pile sest vidée, la chaîne est valide.

111 Exemples dapplication 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.

112 Exemples dapplication 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: * +

113 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 * - Exemples dapplication des piles

114 Evaluation en Postfixe Considérons lexpression en postfixe suivante: * * Algorithme Initialiser la pile à vide; while (ce nst pas la fin delexpression postfixée) { prendre litem 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) { dépiler dans x; effectuer opérateur(x); empiler le résultat obtenu; } 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. Exemples dapplication des piles

115 Infixe à Postfixe Algorithme initialise la pile et loutput postfixe à vide; while(ce nest pas la fin de lexpression 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) dépiler sur x et concaténer x à postfixe; Bien entendu la notation postfixe ne sera pas dune grande utilité sil nexistait pas un algorithme simple pour convertir une expression infixe en une expression postfixe. Encore une fois, cet algorithme utilise une pile.

116 Exemples dapplication des piles Infixe à Postfixe Algorithme initialise la pile et loutput postfixe à vide; while(ce nest pas la fin de lexpression 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) dépiler sur x et concaténer x à 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 : + - Lalgorithme 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.


Télécharger ppt "Structures de données IFT-10541 Abder Alikacem Les piles Département dinformatique et de génie logiciel Édition Septembre 2009."

Présentations similaires


Annonces Google