UNIVERSITE ABDELMALEK ESSAADI

FACULTE DES SCIENCES ET TECHNIQUES

TANGER

Dpartement de Gnie Informatique

Module : Complexit des algorithmes

Master Mathmatiques Appliques et Informatique
Encadr par :

Professeur Chakkor Saad

E-mail : saadchakkor@gmail.com Anne Universitaire : 2011-2012
21/11/2012

Introduction
Comment valuer les performances d'un algorithme ? La complexit d'un algorithme est une mesure du temps (nombre d'oprations effectues par l'algorithme ) requis par l'algorithme pour accomplir sa tche, en fonction de la taille (taille ncessaire pour stocker les diffrentes structures de donnes pour l'excution) de l'chantillon traiter. On dira d'un problme qu'il est aussi complexe que le meilleur algorithme connu pour le rsoudre. Ces deux concepts sont appels la complexit en temps et en espace de l'algorithme.
2 21/11/2012

Introduction
La complexit algorithmique permet de mesurer les performances d'un algorithme et de le comparer avec d'autres algorithmes ralisant les mme fonctionnalits. La complexit algorithmique est un concept fondamental pour tout informaticien, elle permet de dterminer si un algorithme et meilleur qu'un algorithme et s'il est optimal ou s'il ne doit pas tre utilis. .

Algorithme

21/11/2012

Temps d'excution

Le temps d'excution d'un programme dpend : 1. du nombre de donnes, 2. de la taille du code, 3. du type d'ordinateur utilis (processeur, mmoire), 4. de la complexit en temps de l'algorithme abstrait

21/11/2012

Qualits d'un algorithme

1. Maintenable : (lisible, facile comprendre, coder, dboguer), 2. Rapide 3. Prcision, la stabilit et la scurit. 4. La finitude: lalgorithme doit produire la sortie souhaite en un nombre fini (mais peut-tre trs grand) dtapes, quelque soit lentre 5. Lefficacit 6. La gnralit sapplique tous les problmes dune forme dsire

21/11/2012

Qualits d'un algorithme

La complexit en temps dun algorithme est habituellement fonction de la taille des entres
La complexit en moyenne est souvent difficile obtenir

21/11/2012

Complexit en temps
T(algo,d) = temps dexcution de lalgorithme algo appliqu aux donnes d Complexit au pire : T max (algo,n) = max {T(algo,d), d de taille n} Complexit au mieux : T min (algo,n) = min {T(algo,d), d de taille n} Complexit en moyenne : T MOY (algo,n) =

p(d)T(algo, d)
21/11/2012

d taille n

O p(d) = probabilit davoir lentre d

8

Complexit : Analyse Thorique

On tudie la complexit en temps dun algorithme avant de limplmenter, pour sauver le temps et de l $$$$ Se fait partir du pseudo-code de lalgorithme et non de limplmentation Caractrise le temps dexcution comme une fonction de n, la taille de lentre Prend en considration toutes les entres indpendant de lenvironnement utilis (hardware, software)
9 21/11/2012

Calculer complexit d'un algorithme

il convient tout d'abord de compter le nombre d'oprations impliques par son excution. Notation O : La notation la plus utilise pour noter la complexit d'un algorithme est la notation O (ordre de...), qui dnote un ordre de grandeur. Exemple : on dira d'un algorithme qu'il est O(15) s'il ncessite au plus 15 oprations (dans le pire cas) pour se complter.
10 21/11/2012

Calculer complexit d'un algorithme

un algorithme de complexit O(2n + 8) prendra huit (8) oprations, plus deux (2) oprations supplmentaires par lment du tableau. Algorithmes complexit constante : Exemple :

11

double volume_sphere (const double rayon) { const double PI = 3.14159; // (0) double volume; volume = 4.0 / 3.0 * PI * rayon * rayon * rayon; // (1) return volume; // (2) }
21/11/2012

Calculer complexit d'un algorithme

L'instruction note (0) est l'affectation d'une valeur une constante. On peut compter celle-ci comme tant une opration. L'instruction note (1) est compose de cinq oprations arithmtiques et d'une affectation. On peut la compter comme six (6) oprations ou comme une seule L'instruction note (2), la production de la valeur rsultante de l'excution de la fonction, est aussi une opration.

12

21/11/2012

Calculer complexit d'un algorithme

Si on additionne tout a, on arrive (2) oprations, si on ne compte pas l'affectation d'une valeur la constante opration (0) et si on compte l'instruction (1) comme une seule opration, On arrive huit (8) oprations si on compte les instructions de manire plus rigide. L'algorithme sera donc O(2) ou O(8), tout dpendant de la manire de compter les oprations.

L'important ici n'est pas la valeur exacte entre les parenthses suivant le O, mais le fait que cette valeur soit constante.
13 21/11/2012

Calculer complexit d'un algorithme

Lorsqu'un algorithme est O(c) o c est une constante, on dit qu'il s'agit alors d'un algorithme en temps constant. Une complexit constante est la complexit algorithmique idale, car peu importe la taille de l'chantillon traiter, l'algorithme prendra toujours un nombre fix l'avance d'oprations pour raliser sa tche. Tous les algorithmes en temps constant font partie d'une classe nomme O(1). En gnral, qu'un algorithme soit O(3), O(17) ou O(100000), on dira de lui qu'il est en fait O(1)
14 21/11/2012

Calculer complexit d'un algorithme

Algorithmes complexit logarithmique : Les algorithmes de ce genre auront la proprit suivante: On leur donne un chantillon de taille n traiter, et ils font en sorte (dans une rptitive) de diminuer (de moiti) chaque itration la partie de l'chantillon qu'il vaut la peine de traiter.

Exemple de recherche dichotomique

15 21/11/2012

Calculer complexit d'un algorithme

Supposons qu'on demande quelle position de ce tableau se trouve un lment d'une valeur X, et que le rle de notre algorithme soit de retourner l'index o se trouve X ou de retourner un indicateur d'erreur si l'lment ne sy trouve pas.

Recherche squentielle :
int trouver_indice (const int tab[], const int TAILLE, const int val); int main () { const int MAX = 9; int Tableau [MAX] = // le contenu est tri en ordre croissant { 3, 4, 6, 8, 17, 22, 199, 201, 202 }; cout << "L'lment de valeur " << 4 << " se trouve l'indice " << trouver_indice (Tableau, MAX, 4) << endl; } 16

21/11/2012

Calculer complexit d'un algorithme

L'lment de valeur 4 se trouve l'indice 1 La solution simple mais inefficace
int trouver_indice (const int tab[], const int TAILLE, const int val) { int indice, compteur; compteur = 0; while (compteur < TAILLE && tab[compteur] != val) ++compteur; if (compteur < TAILLE) // si la valeur a t trouve indice = compteur; else indice = INDICE_INVALIDE; return indice; }

17

Un certain nombre d'oprations incontournables qui devront toujours tre considres quoiqu'il arrive.

21/11/2012

Calculer complexit d'un algorithme

On compte en fait ici quatre (4), soit avant la boucle, l'initialisation de la variable compteur, et aprs la boucle, la comparaison de compteur avec TAILLE, l'affectation d'une valeur la variable indice, et la production de la valeur de retour. dans le meilleur cas (si val se trouve l'lment 0 de tab[]), il nous faut seulement 2+4 oprations pour produire la solution, o le 2 constitue les deux conditions valuer au dbut de la boucle, et le 4 est le nombre d'oprations incontournables faire;

18

21/11/2012

Calculer complexit d'un algorithme

dans le pire cas (si val se trouve l'lment TAILLE-1 de tab[], ou si Valeur n'est pas du tout prsente dans tab[]), il nous faut par contre 3*TAILLE+4 oprations pour produire la solution (deux comparaisons et une incrmentation de compteur par tour de boucle, pour TAILLE itrations, donc 3*TAILLE, ce quoi s'ajoutent les 4 oprations de base);

19

21/11/2012

Calculer complexit d'un algorithme

dans le cas moyen (qui est ici le plus pertinent, si on assume que la fonction pourra tre appele de manire uniforme pour des lments prs du dbut de tab[], et prs de la fin de tab[]), il nous faudra par contre 3*(TAILLE/2)+4 oprations pour produire la solution. Raliser le comme exercice

20

21/11/2012

Calculer complexit d'un algorithme

Cela signifie qu'en moyenne, cet algorithme ncessitera : 19 (3*(10/2)+4) oprations pour un tableau de 10 lments; 154 (3*(100/2)+4) oprations pour un tableau de 100 lments; 1504 (3*(1000/2)+4) oprations pour un tableau de 1000 lments; 15004 (3*(10000/2)+4) oprations pour un tableau de 10000 lments; La croissance de complexit concrte est assez visible, nous procderons avec une meilleure solution

21

21/11/2012

Calculer complexit d'un algorithme

La solution de complexit logarithmique Examinons maintenant une solution plus efficace, et analysons rapidement le nombre d'oprations impliques (en fonction de TAILLE) :
const int INDICE_INVALIDE = -1; int trouver_indice (const int tab[], const int TAILLE, const int val) { int indice, plafond, plancher; bool trouve; // Initialisation indice = INDICE_INVALIDE; plafond = TAILLE - 1; plancher = 0; trouve = false;
22

// Traitement while (!trouve && plancher <= plafond) { const int MILIEU = (plancher + plafond) / 2; // risqu! if (val == tab[MILIEU]) { trouve = true; indice = MILIEU; } else if (val < tab[MILIEU]) plafond = MILIEU - 1; else // val > tab[MILIEU] plancher = MILIEU + 1; } return indice;

21/11/2012

Calculer complexit d'un algorithme

On y compte quatre oprations avant le traitement, et une autre juste aprs, ce qui fait que nous ayons 5 oprations faire quoi qu'il arrive. 2 oprations dans le teste de la condition de poursuite de la boucle; 3 oprations si, l'intrieur de la boucle, le premier test de condition est un succs (si on entre dans le if); 3 oprations si, l'intrieur de la boucle, le premier test de condition choue mais le second est un succs (si on entre dans le else if); trois oprations si, l'intrieur de la boucle, le premier test de condition choue et qu'il en va de mme pour le second (si on entre dans le else).

23

21/11/2012

Calculer complexit d'un algorithme

Le pire cas est donc d'liminer successivement la moiti des lments restant explorer jusqu' ce qu'il n'en reste plus qu'un seul, qui sera alors le bon ou encore qui indiquera que l'lment cherch est absent du tableau. si on explore un tableau de 10 lments, on aura besoin au pire de 4 itrations (le tableau dbutera 10 lments, puis passera 5, puis 2, puis un seul); L'quation gnrale dit que cet algorithme est de complexit O(b+(i*log2n)) o n est la taille du tableau, b est le nombre incontournable d'oprations (ici, b==5) et i est la complexit d'une seule itration (ici, i==5).

24

21/11/2012

Calculer complexit d'un algorithme

En augmentant les chantillons, la courbe logarithmique serait plus pratique et plus optimale.

25

21/11/2012

Calculer complexit d'un algorithme

Algorithmes complexit linaire Ce sont des algorithmes pour lesquels le nombre d'tapes effectuer variera en proportion directe de la taille de l'chantillon traiter (si l'chantillon crot par un facteur de 100, la complexit sera accrue elle aussi par un facteur de 100). Exemple : un algorithme qui parcourt chaque lment d'une liste chane, ou qui fait la somme des lments d'un tableau (ici O(3+n*5))

26

21/11/2012

Calculer complexit d'un algorithme

int somme_elements (const int tab[], const int TAILLE) { int somme = 0; for (int compteur = 0; compteur < TAILLE; ++compteur) somme += tab[compteur]; // attention aux dbordements! return Somme; }
27 21/11/2012

Calculer complexit d'un algorithme

int somme_elements (Noeud *p) { int somme = 0; while (p) { somme += p->valeur; // mettons; attention aux dbordements! p = p-> successeur; } return somme;
28

21/11/2012

Calculer complexit d'un algorithme

avec une liste chane (O(2+n*5)) La simplification normale s'applique : on limine l'addition de constantes, puis la multiplication par des constantes, pour raliser que la croissance de la complexit dpend directement de la taille de l'chantillon.

29

21/11/2012

Calculer complexit d'un algorithme

Algorithmes complexit quadratique On dira d'un algorithme de complexit O(n2) qu'il est de complexit quadratique. Notons seulement qu'il existe plusieurs autres niveaux de complexit (par exemple, des complexits comme O(n3), O(n4), ou des complexits mettant en relation plusieurs variables comme O(n+m2)).

30

21/11/2012

Calculer complexit d'un algorithme

est possible de calculer la complexit d'un algorithme, et de comparer la complexit relative de deux algorithmes pour choisir le plus efficace. Certains algorithmes en apparence simples sont extrmement lents; il convient donc de choisir nos solutions avec prudence.

31

21/11/2012

Calculer complexit d'un algorithme

Exemple d'algorithme complexit quadratique : un algorithme de tri bulles, L'algorithme propos droite est de complexit O((2+n)*(2+n)) dans le meilleur cas, et O((2+n)*(5+n)) dans le pire cas; on parle donc aprs simplification d'un algorithme O(n*n), ou plus simplement O(n2).

32

21/11/2012

Calculer complexit d'un algorithme

il existe des algorithmes (dites non polynomiales , dont la complexit ne s'exprime pas sous la forme d'un polynme) qu'il faut viter si on en a le choix. On parle par exemple d'algorithmes de complexit O(2n).

33

21/11/2012

Calculer complexit d'un algorithme

34

21/11/2012