Structures de données IFT-2000 Abder Alikacem Introduction Semaine 1 Département d’informatique et de génie logiciel Édition Septembre 2009

Structures de donnéesIFT-2000

Abder AlikacemAbder Alikacem

Introduction Semaine 1

Département d’informatique et de génie logiciel

Édition Septembre 2009

! +

Plan

• Introduction• Analyse et abstraction• Modélisation

• Types de données abstraits• Spécifications• Implantation

• Plan du cours et modalités

Viny, la mascotte du cours!!Viny, la mascotte du cours!!

Conventions de représentation

Conventions de représentation de l’information(Interface):• integer idem pour tout programme sur un même ordinateur,

utilisant le même langage: int x;

Conventions d’utilisation (Opérateurs):• integer pas de décimales: x = 5/2;

D’une manière générale, pour définir un type de données, on a besoin dedécrire éventuellement:

• son nom (syntaxe);• sa sémantique;• son domaine de valeurs;• ses contraintes;• etc..

+ son comportement: { opérateurs }

Interface publique

Conventions de représentation

0 0 00

0 0 ±00

± •bit de signe•complément à 1: C1

•complément à 2: C2

Structuration de base = types simples (ex. le type int)

• convention de représentation interne (Modèle interne):

• int x, y;

• choix de représentation interne {implantation de l’interface}

Modèles internes

Conventions transparentes

Transparence des types de base:

00011101010101000101010101010010101010000111111100000101….

0 0 0 1 1

int x;

y = x++;

Besoin de types plus complexes!

• Caractéristiques d’un système sont souvent difficiles à être représentées directement dans un ordinateur.

• Existences de distances conceptuelles.

• Comment réduire ces distances?• Analyse (décomposition descendante) du domaine• Abstraction (à partir des objets informatique de base jusqu’à une

possible représentation du réel)•Encapsulation• Masquage d’information

• Cacher les secrets d’une implémentation.

C’est la modélisation!

Modélisation:

• Réalité Modèle

Construction d’un modèle

Modélisation:



Modélisation:



x

Modélisation:



x

Modélisation:


float x;


struct Pt { float x; float y; float z; } ;

float x;

x

Modélisation:



struct Pt { float x; float y; float z; } ;

struct Plan { pt p[4]; } ;

x

Modélisation:


float x;


struct Boite { Plan pl[6]; };

struct Pt { float x; float y; float z; } Pt;

x

Modélisation:


float x; struct Plan { Pt p[4]; };


struct Pt { float x; float y; float z; };

Boite b1;

x

Modélisation:


float x; struct Plan { Pt p[4]; };

struct Boite { Plan pl[6]; };


Modélisation = transfert

Boite b1;…b1.rotation(b1,45);…

Modélisation:


Création d’un modèle

struct boite { Plan pl[6]; };

struct Pt { float x; float y; float z; };

struct Plan { Pt p[4]; };

float x;Boite b1;…b1.rotation(b1,45);…

Modélisation:• modèle près de la réalité• modèle distant des détails d’implantation

typedef struct { plan pl[6]; } boite;

typedef struct { float x; float y; float z; } pt;

typedef struct { pt p[4]; } plan;

float x;Boite b1;…b1.rotation(b1,45);…

boîte noire

Modélisation:• modèle près de la réalité• modèle distant des détails d’implantation

Les types de données abstraites (TDA)

Programme indépendant de l’implantation du type Boite:

Boite b1, b2, b3;b1.creer(…);b2 = b1;b3 = b2;b1.rotation(45);b2.poseSur(b3);

Boite est alors un type abstrait!

Les types de données abstraites (TDA)

• est défini uniquement• par ses conventions d’utilisation• par le comportement des objets de ce type (i.e., par les méthodes applicables sur les objets de ce type)

• ne décrit pas le modèle d’implantation choisi

• sert à isoler les programmes des données (structuration interne)• crée une indépendance des applications face aux modèles d’implantation (continuité de la programmation structurée)

Incarnation d’un TDA

Une incarnation (une réalisation, une mise en œuvre, une « implémentation ») d'un TDA se concrétise par :

•L’interface (fichier .h)•Et la définition (i.e le code) des opérations primitives dans un langage particulier

L’implémentation (fichier .cpp)

les programmeurs ont deux casquettes:• le concepteur du TDA qui met en œuvre les primitives et doit connaître la représentation interne adoptée. On parle de programmation de bas niveau.• l'utilisateur du TDA qui ne connaît que les services (les opérations) et n'accèdent jamais à la représentation interne. On parle de programmation de haut niveau.

//Fichier ModeleImplantationListe.h#ifndef _LISTEC__H#define _LISTEC__H#define MAX_LISTE 100typedef enum {FAUX, VRAI} Bool;

typedef struct{

int tab[MAX_LISTE];int cpt;

} Liste; #endif

//Fichier Liste.h#include "ModeleImplantationListe.h"#include "CodesErreur.h"

Liste initListe(int * err);/* */int tailleListe(Liste l, int *err);/* */Bool estVideListe(Liste l, int *err);/* */Liste ajouterListe(Liste l, int x, int pos, int *err);/* */// etc..

// Fichier Liste.h#include <iostream>

#ifndef _LISTEC__H #define _LISTEC__H

class Liste {public: Liste(); //constructeur ~Liste(); //destructeur void ajouter (int x, int pos)

throw(range_error, length_error); int taille() const ; bool estVide() const; //etc…private: static const int MAX_LISTE = 100; int tab[MAX_LISTE]; int cpt;

};#endif

Interface en C++

Interface en C

Exemple d’une interface d’un type abstrait

C’est la partie publique

main()

//Fichier ModeleImplantationListe.h#ifndef _LISTEC__H#define _LISTEC__H#define MAX_LISTE 100typedef enum {FAUX, VRAI} Bool;

typedef struct{

int tab[MAX_LISTE];int cpt;

} Liste; #endif

// Fichier Liste.h#include <iostream> using namespace std;

#ifndef _LISTEC__H#define _LISTEC__H

class Liste { public: … //l’interface publique private: static const int MAX_LISTE = 100; int tab[MAX_LISTE]; int cpt; };#endif

En C++En C

Modèle d’implantation

C’est la partie privée

Exemple

Exemple d’une implémentation en C

#include "Liste.h«

/* Commentaires d’implémentation de la fonction*/Liste ajouterListe (Liste l, int x, int pos, int *err){ if (l.cpt >= MAX_LISTE)

{/* La liste est pleine. */*err = PAM;return l;

}/*A: La liste n'est pas pleine */

if ((pos < 1) || (pos > (l.cpt + 1))){

/* Le paramètre pos est invalide */*err = PERR;return l;

}

/*A: pos >= 1 et pos <= taille de la liste + 1 */*err = OK;

//etc...return l;

}

Exemple d’une implémentation en C++

void Liste::ajouter (int x, int pos) throw(out_of_range, length_error){

if (cpt==MAX_LISTE) throw length_error("Ajouter:La liste est pleine");

if (pos < 1 || pos > this->taille() +1) throw out_of_range("Ajouter:Position d'ajout erronée"); //etc…}

#include "Liste.h"

int main(){ Liste l;

try //on essaie un ajout{l.ajouter(1,1); l.ajouter(2,2); l.ajouter(4,8); // erreur..//…

} catch(exception& e) { cerr<<"ERREUR: " <<e.what(); …; } .... return 0;}

/** Commentaire style Doxygen * \fn void Liste:: ajouter (int x, int pos) * * \param[in] x Élément à ajouter * \param[in] pos Position où insérer l'élément * */

Un main de test:Fichier Main.cpp

#include "Liste.h"

Interface =

ensemble d’opérations ou servies fournies sur un type abstrait

= (conventions et contraintes + comportement)

={ prototypes des opérateurs} + spécifications formelles

donnéesprogramme

int x, y;

y = x + 1;

Spécifications d’une interfacemain()

Spécifications « langage C »

Exemple: ajout dans une liste ordonnée L L +i x

• prototype de la fonction implantant l’opérateur:• Liste ajouterListe(Liste l, int x, int pos, int *err);

• préconditions conditions devant être vraies au départ pour assurer le bon fonctionnement de l ’opérateur

• l ne doit pas être pleine et pos [1,|L|+1]

• postconditions conditions étant vraies (observables) après l’application (correcte) de l’opérateur

• l contient x et *err = OK si les préconditions sont respectées• l est inchangée sinon et

*err contient:PAM si L est pleine,PERR si pos [1,|L|+1]

• valeur retournée en output de l’application de l ’opérateur:• l mise à jour ou l inchangée en cas d'erreurs

Spécifications version dOxygen (dans une classe)// Le type Liste

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(int x, int pos) throw(range_error, length_error);

...

private:

...//Modèle d'implantation

};

Fichier Liste.h

Objectifs du cours

Programmation des structures de données et des algorithmes qui les manipulent.

• Concepts : abstraction, généricité, encapsulation, programmation orienté objet

• Techniques : la manipulation des pointeurs, la gestion de la mémoire dynamique

Structures de données

•Listes, Piles, Files, Arbres, Graphes, Tables de dispersion

•Tris

Choix : Présentation sous forme de Types de Données Abstraits• Analyse d’algorithmes (notation asymptotique)• Écriture de programmes lisibles et efficaces (complexité)

Discussion sur le plan de cours

• Contenu du cours• Pré-requis• Évaluations• Apprentissage du langage C++• Compilateurs, OS• Notes de cours et le manuel recommandé• Site Web, liste de diffusion, forum, courriel• Laboratoires, autres exercices• SVN, dOxygen, Eclipse, VS 2008• Les équipes dans les TPs• Charge de travail• Conseils

•Méthode de travail•Utilisation du site Web du cours

Structures de données

IFT-2000

Abder AlikacemAbder Alikacem

Analyse d’algorithmesSemaine 1 (suite…)

Département d’informatique et de génie logiciel

! +

Édition Septembre 2009

Plan

Introduction Efficacité des algorithmes Analyse algorithmique Notation O (big-oh) Instruction Baromètre Comparaison entre les classes de complexité

Efficacité des algorithmes

Habituellement on mesure l’efficacité d’un algorithme par sa vitesse.

• C’est-à-dire la durée que met l’algorithme à produire ses résultats.

On veut savoir combien de temps cela prend de résoudre une instance de taille n du problème P:

• données(n) + Algorithme(P) ==> résultat(n).• temps mis ? (en microsecondes, cycles d’horloge, nombre

d’instructions exécutées, etc..)On prend en compte la taille n des données

Parfois, on considère aussi la mémoire nécessaire.


Approche empirique: mesure de performances.• essayer l’algorithme sur différents jeux de données bien

choisis.

Avantages: • résultats réalistes.

Inconvénients:• coûteux et long• dépend du processeur, de l’OS • dépend de l’implémentation


Approche algorithmique:• estimer le nombre de pas de l’algorithme en fonction de la taille

des données.

Avantages: • résultats généraux: on ne dépend pas du processeur, de l’OS ou de l’implémentation

• Estimation rapide et peu coûteux

Inconvénients:• prédictions parfois approximatives.

Dans notre cours, on va s’intéresser à l’approche algorithmique pour la détermination de l’efficacité d’un algorithme. Relevez qu’on parle souvent de complexité d’un algorithme lorsqu’on s’intéresse à son efficacité.

Approche algorithmique

Analyse détaillée :• Avantage :Très précise• Désavantage : Long à calculer

Solution: Analyse asymptotique du comportement de l’algorithme lorsque le(s) paramètre(s) de l’algorithme tendent vers l’infini:

• Avantage: Parfois facile à calculer• Désavantage: Parfois moins précis

Notation O (big-oh)

On Cherche une fonction simple qui dépend de la taille n de l’instance en entrée dans un algorithme qui résout un problème donnée et qui décrit la borne supérieure de la complexité de l’algorithme.

Pour déterminer la complexité d’un algorithme dans la notation O(), on doit d’abord identifier des opérations de base (instructions baromètres), puis trouver la fonction f(n) qui compte le combien de fois cette instruction baromètre est effectuée dans l’algorithme.

Nous verrons à partir d’un exemple qui suit comment déduire la

complexité d’un algorithme dans la notation O() à partir de la fonction f(n).

Exemple

void triSelection(int tab[MAXTAB], int n){

int PositionMin, temp, i, j;

for (i = n-1; i > 0; i--){

PositionMin = i;for (j = 0; j < i; j++){

if (tab[j] < tab[PositionMin]){

PositionMin = j;}

}temp = tab[i];tab[i] = tab[PositionMin];tab[PositionMin] = temp;

}}



for (i = n-1; i > 0; i--){

PositionMin = i; //b1for (j = 0; j < i; j++){


PositionMin = j;}


}}

// i * a

//b2

Possible baromètre

Exemple

Exemple (suite)

for (i = n-1; i>0; i--)

{Coût b1 /* PositionMin = i */

Coût i*a; /* pour exécuter la boucle interne*/

Coût b2; /* pour l'échange de tab[i] et tab[PositionMin] */

}

Exemple (suite)Exemple (suite)

1

1

( ) ( )n

i

f n ai b

b = b1 + b2

1 1

1 1

( )n n

i i

f n a i b

( 1)( ) ( 1)

2

n nf n a n b

2( ) 2 2

a af n b n bn

Comportement de la fonction f(n) = an2 + bn + c quand n est très grand (n )

a = 0.0001724, b = 0.0004, c = 0.1

n f(n) an2 % du n2

125 2.8 2.7 94.7

250 11.0 10.8 98.2

500 43.4 43.1 99.3

1000 172.9 172.4 99.7

2000 690.5 689.6 99.9

Notation O(g(n)) (big-oh)

Pour un nombre n assez grand f(n) an2

Temps d'exécution de l’algorithme est donné parf(n) = an2 + bn + c

g(n) = n2

On dit que l'algorithme est en O(n2)

f(n)

1

log n

n2n2n

Notation O(g(n)) (big-oh)

Il y a différentes classes de fonctions qu’on peut exprimer dans la notation O() : O(1), O(n), O(n2), O(n3), O(log n), …

n

Exemple (suite)

1

1

( ) ( )n

i

f n ai b

b = b1 + b2

1 1

1 1

( )n n

i i

f n a i b

( 1)

( ) ( 1)2

n nf n a n b

2( ) 2 2

a af n b n bn

L’algorithme est en O(n2)

Exemple (suite et fin)

L’algorithme est en O(n2)



for (i = n-1; i > 0; i--){

PositionMin = i; for (j = 0; j < i; j++){


PositionMin = j;}


}}

Le bon baromètre

int minimumOn2(int tableau[],int taille){ int i,j; for(i=0;i<taille;i++) { j=0; while(j<taille && tableau[i]<=tableau[j] ) {

j++; } if(j == taille) return tableau[i]; } return tableau[i];}

int minimumOn(int tableau[],int taille){ int i,min = tableau[0]; for(i=0;i<taille;i++) {

if( tableau[i]<min) min = tableau[i]; } return min;}

Algorithme #1

Algorithme #2

Exemple 2: chercher le minimum dans un tableau d’entiers

Autres exemples sur les boucles

void f(int n){

for(int i=0;i<n;i++) cout <<‘’Allo\n’’;}

Cet algorithme est en O(n)

void f(int n){

for(int i=0;i<n;i++)for(int j=0;j<n;j++)

cout << i << j << endl;}

Cet algorithme-ci est dans O(n²)


void f(int n) {

for(int i=0;i<n;i++)for(int j=0;j<n;j++)

cout << i << j << endl;for(int i=0;i<n;i++)

cout << i << endl;}

Cet algorithme est en O(n²)

void f(int n){

for(int i=0;i<10000;i++)cout<<’’Allo\n’’;

}

Puisque son temps d’exécution ne dépend pas de n, même si la boucle est très longue, l’algorithme est en O(1). En effet, lorsque le temps d’exécution d’un algorithme ne dépend même pas du nombre d’éléments, ce temps est alors constant et il est dans O(1).


void f(int n){

for(int i=0;i<5340*n;i++)cout <<‘’Allo\n’’;

}

Puisque qu’il faut faire abstraction de toute constante multiplicative, cet algorithme est en O(n).

void f(int n){

for(int i=0;i<n;i++)for(int j=0;j<i;j++)

cout <<‘’Allo\n’’;}

L’algorithme est en O(n²).

Annexe mathématique

• Les séries simplifiées• Rappel sur les logarithmes• Règles de simplification dans la notation O()

En plus, voir document RappelsMath.pdf sur le site Web du cours.

51

Exercice. Analyse d’algorithmes

1- En choisissant l’opération d’affectation comme baromètre, déterminez la fonction f(n) qui exprime le temps de calcul pour l’algorithmes suivant.

2- Déduisez sa complexité dans la notation du O().

s 0 i 1 Tant Que i ≤ n début s s - 1 j 1

Tant Que j ≤ i début

s s + 2 j j+1

fin i i + 1 fin

Laboratoire de la semaine

Soit a1, a2, ..., an, une séquence d’entiers possiblement négatifs.

On veut trouver le couple (i,j) tel que la somme des ak, k=i, ..., j est maximale, avec 1≤ i ≤ j ≤ n

a1 a2 a3 a4 ... an-3 an-2 an-1 an

« Maximum Subsequence Sum Problem »


Il s’agit d’évaluer en termes de notation asymptotique quelques solutions proposées à cette problématique. Il s’agit également de comparer le temps d’exécution de ces solutions pour, d’abord, confirmer la complexité de chacune d’elles et, ensuite, de constater l’énorme différence en temps de calcul qui peut exister entre une solution naïve et une solution plus élaborée.

« Maximum Subsequence Sum Problem »

Fichiers fournis• ModeleTranchesMax.h (définitions de types + inclusions de librairies C++• TrancheMax.h (prototypes des fonctions à implanter)• Algorithmes.cpp (à compléter par l’implémentation des fonctions demandées)• Main.cpp (le programme principal: appel des fonctions implémentant les algorithmes proposés pour déterminer la tranche max dans un tableau d’entiers, mesure du temps d’exécution de chaque algorithme pour des fins de comparaison).


Tous les fichiers fournis dans ce laboratoire ont été documentés avec les balises de Doxygen. Afin de vous familiariser avec, nous vous demandons de compiler tous les fichiers avec cet outil afin de générer la documentation attendue. Nous vous fournissions le fichier de configuration sdd.doxyfile pour cette fin.

Vous trouverez un tutoriel pour utiliser Doxygen (avec le Doxywizard ou bien dans Eclipse si vous utilisez cet IDE) dans la section Travaux Examen/Travaux Pratiques/Doxygen sur le site Web du cours).

Utilisation de Doxygen (génération de documentations automatisée)

L'interface...

/**

* \brief

*

* \pre

* \pre

*

* \post

* \post

*

* \exception

* \exception

*/

Implémentation

...

/**

* \fn

*

* \param[in]

* \param[out]

*

* \return

Section Documentations/Normes de programmation:

•Resume.h (à propos des commentaires Doxygen)

En-tête de fichiers

/**

* \file Liste.cpp

* \brief Le code des opérateurs de la liste.

* \author Abder

* \version 0.1

* \date septembre 2009

*

* Implémentation de la classe générique Liste.

*

*/

Résumé des balises Doxygen utiles pour le cours


Éléments du C++ à découvrir lors de ce laboratoire

• Les entrées/sorties• #include <iostream> // Librairie pour les entrées/sorties• using namespace std;

• ne jamais mettre cette instruction dans les fichiers .h• cin (stdin), cout (stdout), • << (printf du C), >> (scanf du C), endl (saut de ligne)

• Les structs: différence entre le C et le C++ struct SousSequence { int debut; /*!< Indice de début de la sous-séquence dans Sequence*/ int fin; /*!< Indice de fin*/ int somme; /*!< La somme (max) de la sous-séquence*/ };

En C++, le typedef est inutile…



• Gestion des exceptions

• #include <stdexcept> • Le mécanisme try…catch..throw…(voir fichier Main.cpp)

int main(){

... try {

... affiche(trancheMax3(seq, tailleSeq)); ...

} catch (invalid_argument& ia) { cerr << "Invalid argument: " << ia.what() << endl;

} ... return 0;}



• Gestion des exceptions

• Gestion des exceptions dans une fonction…(fichier Algorithmes.cpp)

SousSequence trancheMax1(Sequence a, int taille){ … if (taille<=0) throw invalid_argument("TrancheMax1: argument invalide\n"); …

}

La classe invalid_argument fait partie de <stdexcept>

Éléments du C++ à voir courant la semaine

•Du C au C++•Les entrées/sorties (important pour cette semaine)•L'espace de nommage•Les types vector et string

Voir Section « C++ primer » dans le semainier sur le site Web

Le point sur les normes de programmation

Normes de programmation:

• Commentaires d’interface• Commentaires d’implémentation• Découpage logique d’un 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)

Documents

Structures de données IFT-2000 Abder Alikacem Introduction Semaine 1 Département d’informatique et de génie logiciel Édition Septembre 2009