Complexit (1/2)

Problmatique : on veut pouvoir mesurer l'efficacit d'un algorithme, ce qu'on appelle sa complexit
pour pouvoir prvoir son temps d'excution pour pouvoir estimer les ressources qu'il va mobiliser dans une machine lors de son excution (place occupe en mmoire en particulier) pour pouvoir le comparer avec un autre qui fait le mme traitement d'une autre faon, de manire choisir le meilleur

L'valuation de la complexit peut se faire plusieurs niveaux

au niveau purement algorithmique, par l'analyse et le calcul au niveau du programme, par l'analyse et le calcul au niveau de l'excution du programme exprimentalement

Complexit (2/2)
Jusqu'aux annes 70, seule la mesure exprimentale de la complexit d'un algorithme tait (parfois) effectue Cette valuation exprimentale dpendait normment des machines mais permettait de comparer l'efficacit de diffrents algorithmes si on les crivait dans un mme langage et qu'on les faisait tourner sur une mme machine Si on les faisait tourner sur des machines diffrentes, il fallait valuer la puissance des machines
cette puissance dpend du matriel mais aussi du systme d'exploitation cette puissance varie en fonction des traitements effectus (calculs bruts, sur des entiers ou des rels, calculs lis l'affichage, ...)

noitammargorP te euqimhtiroglA - 2 ertsemeS - euqitamrofnI ecneciL

noitammargorP te euqimhtiroglA - 2 ertsemeS - euqitamrofnI ecneciL

Benchmark
Benchmark (point de rfrence) : batterie de tests consistant faire tourner certains programmes sur une machine pour valuer sa puissance
un benchmark est orient vers certains types de calculs la puissance d'une machine s'exprime gnralement en flops (floating point operations per second)

Puissance des ordinateurs grand public actuels : quelques Gigaflops (106 flops) Puissance des meilleurs super-ordinateurs actuels : environ 1000 Teraflops (1015 flops) (cf. www.top500.org) Exemples de benchmark :
Sandra : benchmark gnraliste sous Windows (www.sisoftware.co.uk) Sciencemark : benchmark orient calculs scientifiques sous Windows Benchmarks sous Linux : lbs.sourceforge.net
3

noitammargorP te euqimhtiroglA - 2 ertsemeS - euqitamrofnI ecneciL

Exemple : change de deux valeurs entires

// change des valeurs de deux variables entier x, y, z; ... // initialisation de x et y z <- x; x <- y; y <- z;

noitammargorP te euqimhtiroglA - 2 ertsemeS - euqitamrofnI ecneciL

Echange de deux valeurs

// change des valeurs de deux variables entier x, y; ... // initialisation de x et y x <- y-x; y <- y-x; x <- y+x;

la premire mthode utilise une variable supplmentaire et ralise 3 affectations la deuxime mthode n'utilise que les deux variables dont on veut changer les valeurs, mais ralise 3 affectations et 3 oprations

Complexit en temps et en espace

Plusieurs complexits peuvent tre values :
complexit en temps : il s'agit de savoir combien de temps prendra l'excution d'un algorithme complexit en espace : il s'agit de savoir combien d'espace mmoire occupera l'excution de l'algorithme

Souvent, si un algorithme permet de gagner du temps de calcul, il occupe davantage de place en mmoire (mais un peu d'astuce permet parfois de gagner sur les deux tableaux) Gnralement, on s'intresse essentiellement la complexit en temps (ce qui n'tait pas forcment le cas quand les mmoires coutaient cher)

Recherche squentielle (1/2)

Exemple : recherche squentielle d'un lment dans un tableau tri de n chaines de caractres
complexit en espace : la place d'un entier (en plus des paramtres) complexit en temps : chaque tour de boucle, on fait : une comparaison d'entiers pour le test de boucle 2 comparaisons de chaines (1 seule si on est sur l'lment recherch) une incrmentation d'entier (sauf si on est sur l'lment recherch)

fonction avec retour boolen rechercheElement2(chaine[] tab, chaine x) entier i; dbut i <- 0; tantque (i < tab.longueur) faire si (tab[i] = x) alors retourne VRAI; sinon si (tab[i] > x) alors retourne FAUX; sinon i <- i + 1; finsi finsi fintantque retourne FAUX; fin
6

noitammargorP te euqimhtiroglA - 2 ertsemeS - euqitamrofnI ecneciL

noitammargorP te euqimhtiroglA - 2 ertsemeS - euqitamrofnI ecneciL

Complexit algorithmique (2/2)

Combien fait-on de tours de boucle? appelons cc le temps mis pour comparer deux chaines, ce le temps mis pour comparer deux entiers et ie le temps mis pour incrmenter un entier si l'lment n'est pas dans le tableau, la recherche squentielle va faire n tours de boucle et la complexit totale sera donc de (2*cc+ce+ie)*n si l'lment est en ieme position, la recherche fera i tours de boucles, la complexit totale sera donc de (2*cc+ce+ie)*(i-1) + (cc+ce) n et i peuvent varier, cc et ie sont des constantes i peut varier entre 1 et n, en moyenne, il vaudra n/2. En moyenne, la complexit en cas de succs sera donc environ de (2*cc+ce+ie)*n/2 cc, ce et ei ne dpendent pas uniquement de l'algorithme mais galement du langage utilis, de la machine sur laquelle on fait tourner le programme

Complexit au pire
La complexit n'est pas la mme selon les droulements du traitement
complexit au pire : complexit maximum, dans le cas le plus dfavorable complexit en moyenne : il s'agit de la moyenne des complexits obtenues selon les issues du traitement complexit au mieux : complexit minimum, dans le cas le plus favorable. En pratique, cette complexit n'est pas trs utile

Le plus souvent, on utilise la complexit au pire, car on veut borner le temps d'excution Si on veut comparer les algorithmes indpendamment des implmentations et des machines, on ne peut comparer que la forme gnrale de la complexit, en particulier la faon dont elle volue selon la taille des donnes
8

noitammargorP te euqimhtiroglA - 2 ertsemeS - euqitamrofnI ecneciL

noitammargorP te euqimhtiroglA - 2 ertsemeS - euqitamrofnI ecneciL

Calcul de la factorielle
Exemple : calcul de la factorielle d'un entier n
complexit en espace : la place de deux entiers (en plus du paramtre) complexit en temps : chaque tour de boucle, on fait : une comparaison d'entiers pour le test de boucle et une incrmentation une multiplication d'entiers et une affectation d'entier il y aura n-1 tours de boucle si ce est le temps mis pour comparer deux entiers, ie celui mis pour l'incrmentation, me celui mis par la multiplication et ae celui mis pour l'affectation, la complexit sera donc de (n-1)*(ce + ie + me + ae) + ae

Paramtre de la complexit
La complexit d'un algorithme est calcule en fonction d'un paramtre par rapport auquel on veut calculer cette complexit Pour un algorithme qui opre sur une structure de donnes (tableau, ...), la complexit est gnralement exprime en fonction d'une dimension de la structure
dans le cas o l'algorithme prend en entre une structure linaire, une seule dimension, il n'y a pas d'ambiguit dans le cas o l'algorithme prend en entre une structure plusieurs dimensions (tableau multidimensionnel, arbre, graphe, ...), il faut prciser en fonction de quelle dimension on calcule la complexit dans le cas o l'algorithme prend en entre une structure plusieurs dimensions, l'algorithme peut avoir des complexits diffrentes selon la dimension considre

Pour un algorithme qui opre sur un nombre, la complexit est gnralement exprime en fonction de la valeur du nombre
01

noitammargorP te euqimhtiroglA - 2 ertsemeS - euqitamrofnI ecneciL

noitammargorP te euqimhtiroglA - 2 ertsemeS - euqitamrofnI ecneciL

fonction avec retour entier factorielle1(entier n) entier i, resultat; dbut resultat <- 1; pour (i allant de 2 n pas 1) faire resultat <- resultat*i; finpour retourne resultat; fin

Recherche dichotomique (1/3)

Exemple : recherche dichotomique dans un tableau tri de n chaines de caractres
on coupe le tableau en deux et on cherche l'lment dans une des deux parties en rptant le mme traitement (on utilise donc deux entiers pour mmoriser les bornes infrieure et suprieur de l'intervalle d'indices considr)

Recherche dichotomique (2/3)

complexit en temps : chaque tour de boucle, on fait une comparaison d'entiers pour le test de boucle 2 comparaisons de chaines (1 seule si on est sur l'lment recherch) 3 oprations lmentaires sur les entiers et une affectation (sauf si on est sur l'lment recherch) au pire, la longueur de la partie du tableau comprise entre i et j est d'abord n, puis n/2, puis n/4, ...., jusqu' ce que n/2t = 1 le nombre de tours de boucles est donc un entier t tel que n/2t = 1 soit 2t = n soit t*log(2) = log(n) ou t = log2(n) finalement, la complexit au pire de la recherche dichotomique sera log2(n)*(ce + 2* cc + 3*oi + aff) c'est plutt compliqu, et la plupart du temps, pour comparer la complexit de deux algorithmes, on utilise une approximation de la complexit

11

21

noitammargorP te euqimhtiroglA - 2 ertsemeS - euqitamrofnI ecneciL

noitammargorP te euqimhtiroglA - 2 ertsemeS - euqitamrofnI ecneciL

fonction avec retour boolen rechercheElement3(chaine[] tab, chaine x) entier i, j; dbut i <- 0; j <- tab.longueur-1; tantque (i <= j) faire si (tab[(j+i)/2] = x) alors retourne VRAI; sinon si (tab[(j+i)/2] > x) alors j <- (j+i)/2 - 1; sinon i <- (j+i)/2 + 1; finsi finsi fintantque retourne FAUX; fin

complexit en espace : la place de deux entiers

Recherche dichotomique (3/3)

Exemple : recherche d'un lment dans un tableau
la complexit au pire de la recherche squentielle est de la forme n*ks o ks est une constante la complexit au pire de la recherche dichotomique est de la forme log(n)*kd o kd est une constante on sait qu'il existe une valeur v telle que pour tout x > v, log(x)*kd < x*ks la recherche dichotomique est donc prfrable ds que la taille du tableau dpasse cette valeur v en pratique, on ne se procupe mme pas de la valeur v, on privilgie toujours un algorithme dont la complexit volue selon le logarithme du paramtre par rapport un algorithme dont la complexit volue selon le paramtre

Complexit approche
Calculer la complexit de faon exacte
n'est pas raisonnable vu la quantit d'instructions de la plupart des programmes n'est pas utile pour pouvoir comparer deux algorithmes

Premire approximation : on ne considre souvent que la complexit au pire Deuxime approximation : on ne calcule que la forme gnrale de la complexit, qui indique la faon dont elle volue en fonction d'un paramtre Troisime approximation : on ne regarde que le comportement asymptotique de la complexit, quand la valeur du paramtre devient assez grande
41

31

noitammargorP te euqimhtiroglA - 2 ertsemeS - euqitamrofnI ecneciL

noitammargorP te euqimhtiroglA - 2 ertsemeS - euqitamrofnI ecneciL

Notation O (1/2)
f et g tant des fonctions, g est dite en O(f) s'il existe des constantes c>0 et n0 telles que g(x) < c*f(x) pour tout x > n0
on note g = O(f) ou g(x) = O(f(x)) on dit que g est domine asymptotiquement par f cette notation est appele notation de Landau

Attention : il ne s'agit que d'une borne suprieure, et partir d'un certain rang, cela indique juste que g ne croit pas plus vite que f partir de ce rang (mais rien n'indique qu'elle croit moins vite, ni qu'elle croit aussi vite) Exemples :

x = O(x2) car pour x>1, x<x2 100*x = O(x2) car pour x>100, x<x2 ln(x) = O(x) car pour x>0, ln(x)<x O(x) = O(x2) x2 = O(x3) car pour x>1, x2<x3 i>0, xi = O(ex) car pour x tel que x/ln(x)>i, xi<ex O(x2) O(x)
51

Notation O (2/2)
La notation de Landau vrifie les proprits suivantes :
si g=O(f) et f=O(h) alors g=O(h) si g=O(f) et k un nombre, alors k*g=O(f) si f1=O(g1) et f2=O(g2) alors f1+f2 = O(g2+g2) si f1=O(g1) et f2=O(g2) alors f1*f2 = O(g2*g2)

Il existe d'autres notations pour dcrire le comportement asymptotique des fonctions :

f domine asymptotiquement g : f(n) = (g(n)) si et seulement s'il existe des constantes c>0 et n0 telles que f(n) c*g(n) pour tout n n0 f est asymptotiquement quivalente g : f(n) = (g(n)) si et seulement s'il existe des constantes c1, c2 strictement positives et n0 telles que c1*g(n) f(n) c2*g(n) pour tout n n0

61

noitammargorP te euqimhtiroglA - 2 ertsemeS - euqitamrofnI ecneciL

noitammargorP te euqimhtiroglA - 2 ertsemeS - euqitamrofnI ecneciL

Types de complexit (1/3)

Complexit constante (en O(1)) : pas d'augmentation du temps d'excution quand le paramtre croit Complexit logarithmique (en O(log(n))) : augmentation trs faible du temps d'excution quand le paramtre croit. C'est typiquement la complexit des algorithmes qui dcomposent un problme en un ensemble de problmes plus petits (par exemple la dichotomie) Complexit linaire (en O(n)) : augmentation linraire du temps d'excution quand le paramtre croit (si le paramtre double, le temps double). C'est typiquement le cas des algorithmes qui parcourent squentiellement des structures linaires (tableaux, listes, ...) Complexit quasi-linaire (en O(nlog(n))) : augmentation un peu suprieure O(n). C'est typiquement le cas des algorithmes qui dcomposent un problme en d'autres plus simples, traits indpendaments et qui combinent les solutions partielles pour calculer la solution gnrale

Types de complexit (2/3)

Complexit quadratique (en O(n2)) : quand le paramtre double, le temps d'excution est multipli par 4. C'est typiquement la complexit des algorithmes avec deux boucles imbriques. Cette complexit est acceptable uniquement pour des donnes de petite taille. Complexit polynomiale (en O(ni)) : quand le paramtre double, le temps d'excution est multipli par 2i. Un algorithme utilisant i boucles imbriques est polynomial. Cette complexit est inacceptable pour des algorithmes utiliss intensivement. Complexit exponentielle (en O(in)) : quand le paramtre double, le temps d'excution est lev la puissance 2. Cette complexit est inacceptable pour des algorithmes utiliss intensivement. Complexit factorielle (en O(n!)) : cette complexit est asymptotiquement quivalente nn (formule de Stirling). Un algorithme de complexit factorielle ne sert rien.

71

81

noitammargorP te euqimhtiroglA - 2 ertsemeS - euqitamrofnI ecneciL

noitammargorP te euqimhtiroglA - 2 ertsemeS - euqitamrofnI ecneciL

Types de complexit (3/3)

Relations asymptotiques entre les complexits :
O(1) = O(log) = O(n) = O(n*log(n)) = O(n2) = O(n3) = O(2n) = O(n!)

Complexit et flops
Temps d'excution d'un algorithme en fonction de sa complexit, de la taille des donnes et de la puissance de la machine utilise
n

Loi de Moore : cot constant, la rapidit des processeurs double tous les 18 mois (les capacits de stockage suivent la mme loi) Conclusion :
il vaut mieux optimiser ses algorithmes qu'attendre des annes qu'un processeur surpuissant soit invent c'est d'autant plus indispensable que le volume des donnes stockes dans les systmes d'informations augmente de faon exponentielle
02

91

s dr a i l l i m 0 1

t i nr e t e n u

s n o il l i b 0 1

s e n n a' d

s e n n a' d

s na 0 0 0 0 1

s ei n nec d

s e n i a m es s e d n o c e s i l l i m s e d n o c es i l l i m

n ) n( g ol n n 2 dr aillim 1 : s e n n o d s e d elli aT

s e d n oces

s er u e h

s e d n o c es

s er u e h

noitammargorP te euqimhtiroglA - 2 ertsemeS - euqitamrofnI ecneciL

noitammargorP te euqimhtiroglA - 2 ertsemeS - euqitamrofnI ecneciL

s e n i am e s

s na 0 1

0 00 0 1

s na

s e d n o c e s s e d n o c e s or c i m

s e n i a m es

s er u e h

n ) n( g ol n n n oillim 1 : se n n o d s e d elli aT

se d n oces il l im

se d n oces

s e d n o c e s or c i m

s e d n o c es i l l i m

se d n oces

s p o lf

21

01

01

01

On peut imaginer encore pire que la factorielle : la fonction d'Ackerman est une de celles qui croissent le plus vite
Ack(m,n) = n+1 si m = 0 Ack(m,n) = Ack(m-1,1) si n=0 et m > 0 Ack(m,n) = Ack(m-1, Ack(m,n-1)) sinon Ack(0,0) = 1 Ack(1,1) = 3 Ack(2,2) = 7 Ack(3,3) = 61 Ack(4,4) ... est suprieur 1080

Cette fonction est utilise comme benchmark pour tester la puissance des super ordinateurs ou des grilles de calcul

Complexit et rcursivit (1/3)

Exemple : calcul rcursif de la factorielle
// cette fonction renvoie n! (n est suppos suprieur ou gal 1) fonction avec retour entier factorielle2(entier n) dbut si (n = 1) alors retourne 1; sinon retourne n*factorielle2(n-1); finsi fin

une comparaison d'entiers le calcul de la factorielle de n-1 une multiplication d'entiers

Si n = 1, le calcul de la factorielle demande :

une comparaison d'entiers
12

22

noitammargorP te euqimhtiroglA - 2 ertsemeS - euqitamrofnI ecneciL

Complexit et rcursivit (2/3)

Si c(n) est la complexit recherche, on a :

c(n) = ce + c(n-1) + me si n c(1) = ce 1

On rsoud cette quation rcursive : c(n) = n*ce + (n-1)*me La complexit thorique de la factorielle rcursive est donc linaire, comme celle de la factorielle itrative Par contre, l'excution, la fonction rcursive est un peu moins rapide (pente de la droite plus forte) du fait des appels rcursifs

noitammargorP te euqimhtiroglA - 2 ertsemeS - euqitamrofnI ecneciL

Si n

1, le calcul de la factorielle de n demande :

Complexit et rcursivit (3/3)

En gnral, drcursiver un algorithme ne change pas la forme de sa complexit, pas plus que passer en rcursivit terminale! Il existe diverses techniques pour la rsolution des quations de rcurrence (cf. UE Outils pour l'informatique 1 et 2)
mthode des fonctions gnratrices et dcomposition des fractions rationnelles transforme en Z ...

Rsolution des rcurrences (1/3)

c(n) = c(n-1) + b
solution : c(n) = c(0) + b*n = O(n) exemples : factorielle, recherche squentielle rcursive dans un tableau

solution : c(n) = an*(c(0) b/(1-a)) + b/(1-a) = O(an) exemples : rptition a fois d'un traitement sur le rsultat de l'appel rcursif

c(n) = c(n-1) + a*n + b

solution : c(n) = c(0) + a*n*(n+1)/2 + n*b = O(n2). exemples : traitement en cot linaire avant l'appel rcursif, tri bulle

c(n) = c(n/2) + b
solution : c(n) = c(1) + b*log2(n) = O(log(n)) exemples : limination de la moiti des lments en temps constant avant l'appel rcursif, recherche dichotomique rcursive

42

noitammargorP te euqimhtiroglA - 2 ertsemeS - euqitamrofnI ecneciL

c(n) = a*c(n-1) + b, a

32

noitammargorP te euqimhtiroglA - 2 ertsemeS - euqitamrofnI ecneciL

Rsolution des rcurrences (2/3)

solution : c(n) = nlog2(a) *(c(1) b/(1-a)) + b/(1-a) = O(nlog2(a)) exemples : rptition a fois d'un traitement sur le rsultat de l'appel rcursif dichotomique

c(n) = c(n/2) + n
solution : c(n) = O(n) exemples : traitement linaire avant l'appel rcursif dichotomique

c(n) = 2*c(n/2) + a*n + b

solution : c(n) = O(n*log(n)) exemples : traitement linaire avant double appel rcursif dichotomique, tri fusion

Rsolution des rcurrences (3/3)

Thorme : soit T(n) une fonction dfinie par l'quation de rcurrence suivante, o b 2, k 0, a > 0, c > 0 et d > 0 : T(n) = aT(n/b) + c*nk La relation entre a, b et k dtermine la fonction T(n) comme suit : si a > bk, alors T(n) (nlogb(a)) si a = bk, alors T(n) (nk * log(n)) si a < bk, alors T(n) (nk)

52

62

noitammargorP te euqimhtiroglA - 2 ertsemeS - euqitamrofnI ecneciL

noitammargorP te euqimhtiroglA - 2 ertsemeS - euqitamrofnI ecneciL

c(n) = a*c(n/2) + b, a