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-2000 Abder Alikacem Les structures de piles et de files Département dinformatique et de génie logiciel Édition Septembre 2009.

Présentations similaires


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

1

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

3 Bilan de la semaine 3 Les normes de programmation Le TP1 Le point

4 Liste avec tableau: 1. Insertion et suppression sont O(n). 2. Précédent et accès direct sont O(1). 3. Tout lespace est alloué à lavance. 4. Pas despace autre que les valeurs. Liste dans une liste chaînée: 1. Insertion et suppression sont O(1). 2. Précédent et accès direct sont O(n). 3. Lespace augmente avec la liste. 4. Chaque élément requiert de lespace pour les pointeurs Comparaison des implantations de la liste

5 Laboratoire #4 (suite du lab#3… Nous vous fournissons 3 packetages, un par projet/implantation que vous devez faire: tableau dynamique liste doublement chaînée liste circulaire Implantation dune liste ordonnée Dans chacun d'eux, vous devez compléter le fichier.inl étant donné le modèle d'implantation décrit dans la partie privée de la classe Liste. Bien entendu, les 3 implantations demandées doivent être génériques. Ces 2 main()Ces 2 main() fournis sont pour tester les 3 packetages (séparément), un main() pour instancier une liste ordonnée d'entiers et un autre pour déclarer une liste d'objets définis dans la classe ClasseTests.h que nousClasseTests.h vous fournissons également.

6 Rappel des éléments du C++ à étudier Semaine 1 Du C au C++ Les entrées/sorties (important pour cette semaine) L'espace de nommage Les types vector et string Semaine 2 Concepts orientés objet Classe et objet Semaine 3 Programmation générique (template) La gestion des exceptions

7 Éléments du C++ à maîtriser les éléments syntaxiques nouveaux par rapport au langage C notion de classe, constructeurs, destructeur constructeur de copie et surcharge de l'op. = (minimum exigé dans une classe) les attributs et méthodes d'une classe: friend, static, const la généricité (template)

8 Le point sur les normes de programmation Normes de programmation: Commentaires dinterface Commentaires dimplémentation Découpage logique dun programme La gestion des exceptions Style de programmation Voir sur le site Web du cours, section Documentations/Normes de programmation: NormesProgrammation.pdf Resume.h (à propos des commentaires Doxygen)

9 L'interface... /** * \brief * * \pre * * \post * * \exception */ Résumé des balises de Doxygen Implémentation... /** * \fn * * \param[in] * \param[out] * * \return Section Documentations/Normes de programmation: Resume.h (à propos des commentaires Doxygen)

10 template class Liste{ public://L'interface... /** * \brief Ajouter un nouvel élément dans la liste * * \pre il y a assez de mémoire pour ajouter l'élément x * \pre la position d'ajout, pos, est comprise entre 1 et |L|+1 * * \post la liste comprend un élément de plus * \post la liste est inchangée sinon * * \exception range_error si la position est erronée * \exception length_error si pas assez de mémoire */ void ajouter(const T& x, int pos) throw(range_error, length_error);... private:...//Modèle d'implantation }; Fichier Liste.h Spécifications « C++ » (version Doxygen)

11 /** * \fn void Liste :: ajouter (const T& x, int pos) * * \param[in] x Élément à ajouter * \param[in] pos Position où insérer l'élément * */ template void Liste ::ajouter (const T& x, int pos) throw(out_of_range, length_error) { Commentaires dimplémentation (version Doxygen)

12 premierederniere … depart arrivee Labyrinthe NoeudListePieces class Piece { ListePortes portes; bool parcourue; string nom; }; class ListePortes { Porte porte; noeudListePortes *acces; } ; class Porte { Piece *destination; Couleur color; } Classes Chemin et FilePieces : ils servent pour la résolution de certaines méthodes demandées TP1

13 Première partie: les piles Introduction et exemples dapplication Description en terme de type abstrait Implantation

14 Piles et files Piles : LIFO : last in, first out DAPS : dernier arrivé, premier sorti inout pile Files : FIFO : first in, first out PAPS : premier arrivé, premier sorti outin file

15 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.

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

17 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

18 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

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

20 Piles : implantation dans un tableau template class Pile { public: Pile(const int max = MAX) throw (bad_alloc); // constructeur... ~Pile (); // destructeur private : T* tab; int sommet; int tailleMax; }; Implantation dans un tableau dynamique

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

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

23 Piles : implantation dans un tableau template void Pile :: empiler(const T& e) throw (length_error){ if (sommet+1 < tailleMax) {sommet ++; 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

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

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

26 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

27 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() const throw (logic_error); // sélecteur : valeur //placée au sommet bool vide() const; //sélecteur : est vide? }; private : Noeud * sommet; // pointeur sur le sommet de la pile int cpt; // Nombre d'élements de la pile void detruire (); //Méthode privée utile pour le destructeur // et lop. = Version 1

28 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;//sommet de la pile int cpt; void detruire (); }; Version 2 Class Nœud interne

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

30 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.

31 Applications des piles Vérification de parenthèses Reconnaissance syntaxique Calcul arithmétique

32 Deuxième partie: les files Introduction et exemples dapplication Description en terme de type abstrait Implantation

33 Files Files : FIFO : first in, first out PAPS : premier arrivé, premier sorti Manipulations (enfiler et défiler) par des points daccès opposés inout file outin file

34 Files Description en termes de type abstrait Le rôle d'une file est de permettre la mise en attente d'informations dans le but de les récupérer plus tard. La première information à être récupérée est celle qui a été mise en attente en premier. Primitives de manipulation: 1. ajouter un nouvel élément dans la file (enfiler); 2. ôter l'élément le plus ancien de la file (défiler); 3. indiquer si la file d'attente est vide; 4. retourner le premier et dernier élément; Etc..

35 Préoccupation de la programmation par objet initialiser une file (constructeurs); détruire une file de ses éléments (destructeur); Constructeur de copie; Surcharge de lopérateur = Files in file

36 La classe File template class File { public: // constructeurs et destructeurs: File() throw(bad_alloc);//constructeur File(const File &) throw(bad_alloc);//constructeur copie ~File(); //modificateurs void enfiler(const T&) throw (length_error); T defiler() throw(logic_error); // sélecteurs int taille() const { return cpt;} bool estVide() const { return cpt==0; } bool estPleine() const { return cpt==TailleMax; } T& premier() const throw (logic_error); // élément en tête de la file T& dernier() const throw (logic_error); // élément en queue de la file // surcharges d'opérateurs File & operator = (const File &) throw (bad_alloc); friend ostream& operator << (ostream& f, const File& q); private://...Modèle d'implantation };

37 TêteQueue Insérer 'Robert' TQ Paul René Marc Paul Paul René René Marc Marc Marc Marc Marc Jean Jean Jean Anne Anne T T T T T T T Q Q Q Q Q Q Q Débordement Vide Insérer 'Paul' Insérer 'Jean' Insérer 'René' Extraire 'Paul' Extraire 'René' Insérer 'Anne' Insérer 'Marc' Implantation par tableau circulaire

38 Implantation: liste circulaire q = (q + 1) modulo MAXELT

39 Files: implantation dans un tableau Implantation dans un tableau dynamique template class File { public: File(const int max = MAX) throw (bad_alloc); // constructeur... ~File (); // destructeur private : T* tab; int tete; int queue; int tailleMax; int cpt; }; Tableau tab réservé dans le tas Constructeur avec un paramètre : taille maximum

40 Files: implantation dans un tableau template File :: File (int max) throw (bad_alloc){ tab = new T [max]; tete = 0; queue = 0; cpt = 0; tailleMax =max; } template File :: ~File () { if (tab!=0) delete [ ] tab; } Constructeur Destructeur

41 Files: implantation dans un tableau template T File :: defiler() throw (logic_error){ if (cpt!=0) { T elementaDefiler = tab[tete]; tete = (tete+1)% tailleMax; cpt--; return elementaDefiler; } else throw logic_error("Defiler: la file est vide!"); } défiler

42 Files: implantation dans un tableau template T File :: enfiler(const T& e) throw (length_error){ if(cpt

43 Files: implantation par listes Implantation dans une liste chaînée template class File { public: File (); File (const File &) throw (bad_alloc); ~File (); File & operator=(const File & 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 tete; // pointeur sur la tête de la file eleme queue; // Pointeur en queue de file int cpt; // cardinalité de la file };

44 Files: implantation par listes template Pile ::Pile () { tete =0; queue = 0; cpt = 0; } template File :: ~File() { if (tete != 0) { Noeud * p; while (tete != 0){ p=tete->suivant; delete tete; tete=p; } } constructeur destructeur

45 Files prioritaires Gestion dune seule file insertion se fait selon la priorité éléments toujours triés selon leur priorité in file in file

46 Files prioritaires Gestion de plusieurs files 1 file par niveau de priorité (sous-liste) une liste triée selon le niveau de priorité avec un bloc descripteur pour la sous-liste correspondante

47 Applications des files Modélisation du phénomène: banque chaîne de montage etc. En informatique: traitement « batch » (en lots) gestion des listes dimpression

48 Principes dune simulation Tantque toujours faire si f nest pas vide alors: tâche = defile(f); exécuter tâche; Fin Tantque Si exécution(tâche) alors: f = enfiler(tâche,f); Processus consommateur Processus producteur simulation: élément = priorité = temps in file in file 11448

49 Laboratoire #5 Le but de ce laboratoire est limplantation de linterface dune pile et dune file génériques. Parmi les exemples de cette semaine, nous vous avons fourni des implantations dune pile dans un tableau dynamique et dune file dans une liste simplement chaînée. Il est question ici de refaire limplantation dune pile et dune file dans une liste simplement chaînée et dans un tableau dynamique respectivement. Il est question également de limplantation dune pile dans un modèle hybride et dune file prioritaire. Téléchargez l'ensemble de l'énoncé. Vous y trouverez entre autres, 2 packetages, une pour une pile et l'autre pour une file. Pour chacun d'eux, vous devez compléter le fichier.inl étant donné le modèle d'implantation décrit dans la partie privée de la classe décrite dans chaque packetage. Nous vous fournissons un main() pour tester chaque implantation. l'ensemble de l'énoncé


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

Présentations similaires


Annonces Google