1 exemples construction et implantation de types de données abstraits

1

Exemples

Constructionet

implantationde

types de données abstraits

2

Dictionnaire.h/* Spécification fonctionnelle du type de donnée abstrait

"Dictionnaire".

Composantes :Chaque composante représente un mot.

Structure : La structure choisie est un ensemble. Chaque composanteest représentée de façon unique par le mot lui-même.

Domaine : Les caractéristiques d'un mot sont :- le mot lui-même (au plus 20 caractères),- le nombre de définitions de ce mot,- les différentes définitions de ce mot (au plus 50

caractères par définition). */

3

Dictionnaire.htypedef char definition_pour_un_mot[50+1];

struct mot{

char nom_du_mot[20+1];int nombre_de_definitions;definition_pour_un_mot * tableau_des_definitions_du_mot;mot * pMot_suivant;

};

typedef mot * Dictionnaire;

4

Dictionnaire.hvoid Construire_dictionnaire(Dictionnaire *pD);/* Permet de construire un dictionnaire vide pointé par pD.

Pré - Nil.Post - Nous avons un dictionnaire vide. */

void Ajouter_Mot( Dictionnaire *pD,

char * Nom_du_mot,int Nombre_de_definitions

);/* Permet d'ajouter un nouveau mot au dictionnaire pD dont le

nombre de définitions est fixé.Pré - Le dictionnaire a déjà été créé et le mot passé en para-

mètre n'existe pas encore.Post - Un nouveau mot dont le nombre de définitions est passé

en paramètre est ajouté au dictionnaire. */

5

Dictionnaire.hvoid Inserer_Definition_Mot

( Dictionnaire *pD,char * Nom_du_mot,int i,char * Definition

);/* Permet d'insérer la i ième définition du mot passé en paramètre.

Pré - Le mot passé en paramètre fait déjà partie du dictionnairepD. 1 <= i <= nombre_de_definitions.

Post - La i ième définition de ce mot est insérée. */

6

Dictionnaire.hbool Existe_Mot

( Dictionnaire *pD,char * Nom_du_mot,int * Nombre_de_definitions

);/* Permet de déterminer si le mot passé en paramètre fait partie ou

non du dictionnaire pD. Si oui, le nombre de définitions prévuesest retourné.

Pré - Le dictionnaire a déjà été créé.Post - Retourne true si ce mot existe, false sinon.

Si le mot existe, le nombre de définitions prévues estretourné. */

7

Dictionnaire.hchar * Acces_Definition_mot

( Dictionnaire *pD,char * Nom_du_mot,int i

);

/* Donne accès à la i ième définition du mot passé en paramètre ouune chaîne vide si cette définition n'est pas disponible.

Pré - Le mot passé en paramètre fait déjà partie du dictionnairepD. 1 <= i <= nombre_de_definitions.

Post - Retourne la i ième définition du mot passé en paramètre.*/

8

Dictionnaire.cpp#include <cassert>#include "Dictionnaire.h"#include <string.h>

void Construire_dictionnaire(Dictionnaire *pD){

*pD = NULL;}

9

Dictionnaire.cppvoid Ajouter_Mot

( Dictionnaire *pD,char * Nom_du_mot,int Nombre_de_definitions )

{int Nb_de_definitions;assert(Existe_Mot(pD, Nom_du_mot, &Nb_de_definitions) == false);mot * pMot = new mot;strcpy(pMot -> nom_du_mot, Nom_du_mot);pMot -> nombre_de_definitions = Nombre_de_definitions;pMot -> tableau_des_definitions_du_mot =

new definition_pour_un_mot[Nombre_de_definitions];for (int i = 0; i < Nombre_de_definitions; i++)

strcpy(pMot -> tableau_des_definitions_du_mot[i], "");pMot -> pMot_suivant = (*pD);*pD = pMot;

}

10

Dictionnaire.cppvoid Inserer_Definition_Mot

( Dictionnaire *pD,char * Nom_du_mot,int i,char * Definition

){

int Nb_de_definitions;assert(Existe_Mot(pD, Nom_du_mot, &Nb_de_definitions));assert((i >= 1) && (i <= Nb_de_definitions));mot * pMot = *pD;while (strcmp(pMot -> nom_du_mot, Nom_du_mot) != 0)

pMot = pMot -> pMot_suivant;strcpy((pMot ->tableau_des_definitions_du_mot)[i-1],Definition);

}

11

Dictionnaire.cppbool Existe_Mot

( Dictionnaire *pD,char * Nom_du_mot,int * Nombre_de_definitions

){

mot * pMot = *pD;while (pMot != NULL)

if (strcmp(pMot -> nom_du_mot, Nom_du_mot) == 0){ (* Nombre_de_definitions) =

pMot -> nombre_de_definitions;return true;

} else pMot = pMot -> pMot_suivant;return false;

}

12

Dictionnaire.cppchar * Acces_Definition_mot

( Dictionnaire *pD,char * Nom_du_mot,int i

){

int Nb_de_definitions;assert(Existe_Mot(pD, Nom_du_mot, &Nb_de_definitions));assert((i >= 1) && (i <= Nb_de_definitions));mot * pMot = *pD;while (strcmp(pMot -> nom_du_mot, Nom_du_mot) != 0)

pMot = pMot -> pMot_suivant;return (pMot -> tableau_des_definitions_du_mot)[i-1];

}

13

Nouveau Dictionnaire.cpp#include "Dictionnaire.h"#include <iostream.h>

void main(){

int i;int Nb_de_definitions;Dictionnaire Dict;

Construire_dictionnaire(& Dict);

Ajouter_Mot(&Dict, "corne", 2);Ajouter_Mot(&Dict, "belier", 3);Ajouter_Mot(&Dict, "etoile", 2);Ajouter_Mot(&Dict, "B.C.G.", 1);

14

Nouveau Dictionnaire.cppInserer_Definition_Mot(&Dict, "belier", 2, "Machine de guerre");Inserer_Definition_Mot(&Dict, "belier", 1, "Mouton male reproducteur");Inserer_Definition_Mot(&Dict, "belier", 3, "Signe du zodiaque");Inserer_Definition_Mot(&Dict, "etoile", 2, "Animal marin");Inserer_Definition_Mot(&Dict, "etoile", 1, "Astre");Inserer_Definition_Mot(&Dict, "B.C.G.", 1,

"Vaccin contre la tuberculose");

if (Existe_Mot(&Dict, "etoile", &Nb_de_definitions)){

for (i = 1; i <= Nb_de_definitions; i++)cout << "etoile" << " " << i << " "

<< Acces_Definition_mot(&Dict, "etoile", i)<< "\n";

} else cout << "Ce mot est absent.";

15

Nouveau Dictionnaire.cppif (Existe_Mot(&Dict, "corne", &Nb_de_definitions)){

for (i = 1; i <= Nb_de_definitions; i++)cout << "corne" << " " << i << " " << Acces_Definition_mot(&Dict, "corne", i) << "\n";

} else cout << "Ce mot est absent.";if (Existe_Mot(&Dict, "plume", &Nb_de_definitions)){

for (i = 1; i <= Nb_de_definitions; i++)cout << "plume" << " " << i << " " << Acces_Definition_mot(&Dict, "plume", i) << "\n";

} else cout << "Ce mot est absent.";}

16

Polynome.h/* Spécification fonctionnelle du type de donnée abstrait "Polynome"

Composantes: Chaque composante représente un terme du polynôme dedegré n.

Structure : La structure choisie est une suite de n+1 termes.

iDomaine : Le i ième terme du polynôme est de la forme a x :

i */struct Polynome{

int degre;float * coefficients;

};

17

Polynome.hvoid Construire_polynome(Polynome *pP, int n);/* Permet de construire un polynôme nul de degré n pointé par pP.

Pré - Nil.Post - Nous avons un polynôme nul de degré n. */

void Inserer_Terme( Polynome *pP,

int i,float Coefficient

);/* Permet d'insérer le i ième terme dont le coefficient est passé en

paramètre.Pré - Le polynôme de degré "degre" a déjà été créé.

0 <= i <= degre.Post - Le i ième terme fait maintenant partie du polynôme.*/

18

Polynome.hfloat Acces_Coefficient_Terme

( Polynome *pP,int i );

/* Permet d'accéder au coefficient du i ième terme du polynômepointé par pP.Pré - Le polynôme de degré "degre" a déjà été créé.

0 <= i <= degre.Post - Retourne le i ième coefficient du polynôme. */

float Evaluer_polynome( Polynome * pP,

float x);

/* Permet d'évaluer le polynôme à x et retourne le résultat.Pré - Le polynôme est déjà créé.Post - Retourne la valeur du polynôme évalué à x. */

19

Polynome.hPolynome * Addition

( Polynome * pP,Polynome * pQ

);/* Permet d'additionner les 2 polynômes passés en paramètres.

Pré - Les 2 polynômes passés en paramètres ont été créés.Post - Retourne la somme de ces 2 polynômes. */

Polynome * Soustraction( Polynome * pP,

Polynome * pQ);

/* Permet de soustraire du premier le deuxième polynôme passés enparamètres.Pré - Les 2 polynômes passés en paramètres ont été créés.Post - Retourne la différence de ces 2 polynômes. */

20

Polynome.cpp#include <cassert>#include "Polynome.h"void Construire_polynome(Polynome *pP, int n){

(*pP).degre = n;(*pP).coefficients = new float[n+1];for (int i = 0; i <= n; i++) (*pP).coefficients[i] = 0.0f;

}void Inserer_Terme

( Polynome *pP,int i,float Coefficient

){

assert((i >= 0) && ( i <= (*pP).degre));(*pP).coefficients[i] = Coefficient;

}

21

Polynome.cppfloat Acces_Coefficient_Terme

( Polynome *pP,int i

){

assert((i >= 0) && ( i <= (*pP).degre));return (*pP).coefficients[i];

}float Evaluer_polynome

( Polynome * pP,float x

){ /* Règle de Horner */

float somme = 0.0f;for ( int i = (*pP).degre; i >= 0; i--)

somme = x * somme + (*pP).coefficients[i];return somme;

}

22

Polynome.cppPolynome * Addition

( Polynome * pP, Polynome * pQ)

{int n;if ((*pP).degre <= (*pQ).degre) n = (*pQ).degre;

else n = (*pP).degre;Polynome * pR = new Polynome;Construire_polynome(pR, n);for(int i = 0; i <= (*pP).degre; i++)

Inserer_Terme(pR, i, Acces_Coefficient_Terme(pP, i));for(i = 0; i <= (*pQ).degre; i++)

(*pR).coefficients[i] += Acces_Coefficient_Terme(pQ, i);return pR;

}

23

Polynome.cppPolynome * Soustraction

( Polynome * pP, Polynome * pQ)

{int n;if ((*pP).degre <= (*pQ).degre) n = (*pQ).degre;

else n = (*pP).degre;Polynome * pR = new Polynome;Construire_polynome(pR, n);for(int i = 0; i <= (*pP).degre; i++)

Inserer_Terme(pR, i, Acces_Coefficient_Terme(pP, i));for(i = 0; i <= (*pQ).degre; i++)

(*pR).coefficients[i] -= Acces_Coefficient_Terme(pQ, i);return pR;

}

24

Essai Polynome.cpp#include "Polynome.h"#include "iostream.h"void main(){

Polynome P, Q;Construire_polynome(&P, 3); Construire_polynome(&Q, 5);Inserer_Terme(&P, 0, 3.5f); Inserer_Terme(&P, 2, -4.1f);Inserer_Terme(&P, 3, 2.3f);Inserer_Terme(&Q, 3, 2.7f); Inserer_Terme(&Q, 5, 1.0f);cout << "P(1) = " << Evaluer_polynome(&P, 1) << "\n";cout << "Q(-1) = " << Evaluer_polynome(&Q, -1) << "\n";cout << "(P + Q)(1) = "

<< Evaluer_polynome(Addition(&P, &Q), 1) << "\n";cout << "(P - Q)(1) = "

<< Evaluer_polynome(Soustraction(&P, &Q), 1) << "\n";}

25

Spécification fonctionnelle du type de donnée abstrait "Le_Banquier"

En jouant au jeu LE BANQUIER, vous pouvez gagner jusqu'à500 000$. Au départ, 26 valises closes renferment chacune unmontant parmi les suivants :

0.01$ 1$ 1 000$ 5 000$5$ 10$ 10 000$ 15 000$20$ 50$ 25 000$ 50 000$75$ 100$ 75 000$ 100 000$200$ 300$ 125 000$ 150 000$400$ 500$ 200 000$ 300 000$750$ 500 000$

Le montant pour chaque valise est généré aléatoirement.

Le montant dans une valise est inconnu du Banquier et duconcurrent à moins que celui-ci l'est déjà choisi auparavant.

26

Pour débuter le jeu, le concurrent met en retrait une des 26 valisessans l'ouvrir. Puis, il passe au premier tour.

À chaque tour, le concurrent doit ouvrir un certain nombre de valisescomme suit :

Tour # 1 : 6 valisesTour # 2 : 5 valisesTour # 3 : 4 valisesTour # 4 : 3 valisesTour # 5 : 2 valisesTour # 6 : 1 valiseTour # 7 : 1 valiseTour # 8 : 1 valiseTour # 9 : 1 valiseTour # 10 : 1 valise

27

À la fin d'un tour, à la lumière des montants dévoilés depuis ledébut du jeu, le Banquier fait un offre au concurrent. Celui-ci peutaccepter l'offre; il repart alors avec le montant que le Banquier luioffre; le jeu est terminé. Le concurrent peut refuser l'offre; il passealors au tour suivant.

Si le concurrent se rend au dixième tour, toutes les valises sontouvertes et le concurrent gagne le montant que renferme la valisemise en retrait.

À chaque étape du jeu, on doit connaître les numéros de valisesouvertes avec leurs montants respectifs de même que les montantsqui n'ont pas encore été choisis. On conserve aussi une trace desdifférentes offres que le Banquier a faites au concurrent.

28

const int Nombre_de_valises = 26;

const float Ensemble_des_montants[Nombre_de_valises] ={ 0.01f, 1, 5, 10,

20, 50, 75, 100,200, 300, 400, 500,750, 1000, 5000, 10000,15000, 25000, 50000, 75000,100000, 125000, 150000, 200000,300000, 500000

};

const int Nombre_de_valises_a_chaque_tour[10] ={6, 5, 4, 3, 2, 1, 1, 1, 1, 1};

29

struct Le_Banquier{

bool Valises_ouvertes[Nombre_de_valises];// TRUE si une valise est ouverte.// FALSE sinon.

float Montants_des_valises[Nombre_de_valises];// Montant associé à chaque valise.

int Numeros_des_valises_associees_aux_montants[Nombre_de_valises];

// Numéro de la valise associé à chaque montant.

int Numero_de_la_valise_en_retrait;// Numéro de la valise que le concurrent décide// de retirer au début du jeu.

30

float Offres_du_banquier[10];// Offre du banquier à chaque tour où le concurrent// décide de poursuivre.

bool Offre_du_banquier_acceptee;

// TRUE si la dernière offre du banquier est acceptée.// FALSE autrement.

int Numero_du_tour;

// Numéro du tour actuel (entre 1 et 10).};

31

void Initier_le_jeu(Le_Banquier *pB);

/* Permet de générer aléatoirement les montants dans les 26valises d'un jeu pointé par pB.Pré - Nil.Post - Les montants des valises sont générés aléatoirement.

Aucune valise n'est ouverte et la valise en retrait n'a pasencore été choisie par le concurrent. Aucune offre dubanquier n'a été faite jusqu'à maintenant. */

void Retrait_d_une_valise(Le_Banquier *pB, int i);

/* Permet au concurrent de débuter le jeu en mettant la valiseno. i en retrait.Pré - 1 <= i <= 26.

Les montants dans les 26 valises ont été générés.La valise en retrait n'a pas encore été choisie.

Post - La valise no. i est mise en retrait. */

32

void Ouverture_des_valises_au_prochain_tour(Le_Banquier *pB, int Numero_des_valises_a_ouvrir[]);

/* Permet au concurrent de passer au tour suivant et de choisir lesvalises à ouvrir selon le tour où l'on est rendu. Cela signifieque le concurrent a rejeté l'offre du banquier si nous ne sommespas au premier tour.Pré - Le nombre de tours effectué jusqu'à maintenant est ≤ 9.

Le nombre de valises à ouvrir correspond exactement aunombre de valises prévu à ce tour.Les nos. de valises à ouvrir n'ont pas déjà été ouverteset ne renferment pas le numéro de valise en retrait.Les offres du banquier ont toutes été rejetées jusqu'àmaintenant.

Post - Les valises choisies à ce tour sont ouvertes et unenouvelle offre du banquier est disponible. Si noussommes au dixième tour, l'offre du banquier coïncideavec le montant de la valise en retrait et le concurrentaccepte automatiquement l'offre du banquier. */

33

float Offre_acceptee(Le_Banquier *pB);

/* Permet d'accepter la dernière offre du banquier.

Pré - Au moins un tour a été effectué. Les offres du banquieront toutes été rejetées jusqu'à maintenant.

Post - La dernière offre du banquier est acceptée et la valeurde cette offre est retournée. */

bool Offre_acceptee_ou_refusee(Le_Banquier *pB);

/* Retourne true si l'offre du banquier est acceptée.False autrement.Pré - Au moins un tour a été effectué.Post - Retourne true si l'offre du banquier est acceptée.

False autrement. */

34

float Derniere_offre_du_banquier(Le_Banquier *pB);

/* Retourne la dernière offre du banquier.

Pré - Au moins un tour a été effectué.Post - Retourne la dernière offre du banquier. */

float Ouverture_de_la_valise_en_retrait(Le_Banquier *pB);

/* Retourne le montant présent dans la valise en retrait.

Pré - La dernière offre du banquier a été acceptée.Post - Retourne le montant présent dans la valise en retrait. */

float Montant_espere_de_la_valise_en_retrait(Le_Banquier *pB);

/* Retourne la moyenne des montants non encore sélectionnés.*/

35

float Montant_espere_avec_un_tour_ideal(Le_Banquier * pB);

/* Retourne la moyenne des montants non encore sélectionnésaprès le prochain tour dans l'éventualité où le concurrentchoisirait au prochain tour les valises dont les montantssont les plus petits.

Pré - Le # de tours effectué jusqu'à maintenant est ≤ 9. */

float Montant_espere_avec_un_tour_desastreux(Le_Banquier * pB);

/* Retourne la moyenne des montants non encore sélectionnésaprès le prochain tour dans l'éventualité où le concurrentchoisirait au prochain tour les valises dont les montantssont les plus élevés.

Pré - Le # de tours effectué jusqu'à maintenant est ≤ 9. */

36

float Montant_minimum_de_la_valise_en_retrait(Le_Banquier *pB);/* Retourne le minimum des montants non encore sélectionnés.*/

float Montant_maximum_de_la_valise_en_retrait(Le_Banquier *pB);/* Retourne le maximum des montants non encore sélectionnés.*/

void Affichage(Le_Banquier *pB);/* Permet d'afficher les montants des valises ouvertes et

les numéros des valises closes. */

float Offre_du_banquier(Le_Banquier *pB);

/* Retourne l'offre du banquier à la fin de chaque tour.Pré - Au moins un tour a été effectué.Post - Retourne l'offre du banquier.

Si 10 tours ont été effectués, l'offre du banquier coïncideavec le montant de la valise en retrait et le concurrentaccepte automatiquement l'offre du banquier. */

37

Raisonnement du BANQUIER

{ Montant espéré avec un tour idéal+

Montant espéré avec un tour désastreux+

Montant espéré de la valise en retrait } / 3

?!!???..!

Moyenne des montants espérés de la valise en retraiten considérant toutes les possibilités qui résultent du choixdu concurrent au tour suivant.