Complexit

Objectifs des calculs de complexit :

- pouvoir prvoir le temps d'excution d'un algorithme
- pouvoir comparer deux algorithmes ralisant le mme
traitement
 Complexit temporelle vs spatiale (1/2)

Exemple : change de deux valeurs entires

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

2
 Complexit temporelle vs spatiale (2/2)

L'efficacit d'un algorithme peut tre valu en temps et en

espace :
- complexit en temps : valuation du temps d'excution de
l'algorithme
- complexit en espace : valuation de l'espace mmoire occup par
l'excution de l'algorithme
Rgle (non officielle) de l'espace-temps informatique : pour gagner
du temps de calcul, on doit utiliser davantage d'espace mmoire.
On s'intresse essentiellement la complexit en temps (ce qui
n'tait pas forcment le cas quand les mmoires coutaient cher)

3
 Paramtre de complexit (1/3)

Le paramtre de la complexit est ce qui va faire varier le temps d'excution

de
l'algorithme.
Exemple : la calcul de la factorielle

Le paramtre de complexit est la valeur de n

4
 Paramtre de complexit (2/3)

Exemple : multiplier tous les lments d'un tableau d'entiers par

un entier donn

Le paramtre de complexit est la longueur du tableau

tab.

5
 Paramtre de complexit (3/3)

Exemple : faire la somme des lments de la premier ligne d'un tableau

deux dimensions

Le seul paramtre de complexit est la longueur de t.

Quand l'algorithme opre sur une structure multidimensionnelle, il

faut bien prciser le paramtre de complexit.
Un algorithme oprant sur de telles structures peut avoir des
complexitsdiffrentes selon la dimension considre.

6
 Calcul de complexit (1/2)

Exemple: la factorielle

On peut fixer des temps d'excution constants chaque

type d'instruction :
affectation d'entier :
comparaison d'entier :
opration lmentaire sur des entiers
Le reteur

7
 Calcul de complexit (2/2)

L'excution de la fonction va prendre:

On a aussi un test `a chaque itration

Le nombre total doprations :
1+1+ (n-1)*(2+2)+1 =4n-1

Au total, le temps d'excution sera de la forme a*n+b

a et b dpendent du langage de programmation et de l'ordinateur
utiliss. 8
 Complexit au mieux et au pire (1/4)

Exemple : recherche squentielle d'un lment dans un tableau

Initialisation 1
Itration n
Test 1
Renvoi 1
Adition + affectation 2
Renvoi 1

Le paramtre de complexit est la taille du tableau d'entre.

Le nombre de tours de boucles varie selon que x est dans le
tableau ou pas, et selon l'endroit o x est prsent.

9
 Complexit au mieux et au pire (2/4)
Initialisation 1
Itration n
Test 1
Renvoi 1
Adition + affectation 2
Renvoie 1

Si x est dans la premire case du tableau : 1 tour de boucle avec la

condition t[i]=x vraie
Si x est dans la deuxime case du tableau : 1 tour de boucle avec la
condition t[i]=x fausse et 1 tour de boucle avec la condition tab[i]=x vraie
...
Si x est dans dernire case du tableau : tab.longueur-1 tours de boucle
avec la condition t[i]=x fausse et 1 tour de boucle avec la condition tab[i]=x
vraie
Si x n'est pas dans le tableau : tab.longueur tours de boucle avec la
condition
tab[i]=x fausse
10
 Complexit au mieux et au pire (3/4)

Lorsque, pour une valeur donne du paramtre de complexit, le temps

d'excution varie selon les donnes d'entre, on peut distinguer :
- La complexit au pire : temps d'excution maximum, dans le cas le plus
dfavorable.
- La complexit au mieux : temps d'excution minimum, dans le cas le plus
favorable (en pratique, cette complexit n'est pas trs utile).
- La complexit moyenne : temps d'excution dans un cas mdian, ou
moyenne des temps d'excution.
Le plus souvent, on utilise la complexit au pire, car on veut borner le
temps d'excution.

11
 Complexit au mieux et au pire (4/4)

Complexit au pire (x n'est pas dans le tableau) : 1+2n+1

Complexit au mieux (x est dans la premire case du tableau) :
1+1+1

Complexit en moyenne : considrons qu'on a 50% de chance que x

soit dans le tableau, et 50% qu'il n'y soit pas, et, s'il y est sa position
moyenne est au milieu. Le temps d'excution est [ (1+1+1) +
(1+2n+1) ] /2,
de la forme a*n+b (avec a et b constantes)
12
 Complexit asymptotique (1/4)

Calculer la complexit de faon exacte n'est pas raisonnable vu la quantit

d'instructions de la plupart des programmes et 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
Troisime approximation : on ne regarde que le comportement
asymptotique de la complexit

13
 Domination asymptotique (1/2)
f et g tant des fonctions, f = O(g) s'il existe des constantes c>0 et n0
telles que
f(x) < c*g(x) pour tout x > n0

f = O(g) signifie que f est domine asymptotiquement par g

14
 Domination asymptotique (2/2)

La notation O, dite notation de Landau, vrifie les proprits suivantes :

- si f=O(g) et g=O(h) alors f=O(h)
- si f=O(g) et k un nombre, alors k*f=O(g)
- 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(g1*g2)
Exemples de domination asymptotique :

Notation : f = (g) s'il existe des constantes c>0 et n0

telles que f(x) c*g(x) pour tout x n0

15
 Classes de complexit (1/3)

O(1) : complexit constante, pas d'augmentation du temps d'excution

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

16
 Classes de complexit (2/3)

O(n2) : complexit quadratique, quand le paramtre double, le temps

d'excution est multipli par 4. Exemple : algorithmes avec deux
boucles
imbriques.
O(ni) : complexit polynomiale, quand le paramtre double, le temps
d'excution
est multipli par 2i. Exemple : algorithme utilisant i boucles imbriques.
O(in) : complexit exponentielle, quand le paramtre double, le temps
d'excution est lev la puissance 2.
O(n!) : complexit factorielle, asymptotiquement quivalente nn

17
Classes de complexit (3/3)

18
 Complexit et temps d'excution 1/1

Temps de calcul pour des donnes de taille 1 million

Loi de Moore (empirique) : cot constant, la rapidit des processeurs

double tous les 18 mois (les capacits de stockage suivent la mme loi).

Constat : le volume des donnes stockes dans les systmes

d'informations augmente de faon exponentielle.

Conclusion : il vaut mieux optimiser ses algorithmes qu'attendre des

annes
qu'un processeur surpuissant soit invent.
19
 exemple : Complexit factorielle 1/5

La Complexite de la procedure :
O(1) + O(n) O(1) + O(1) = O(n)

20
 Exemple : Complexit recherche squentielle 1/5

Initialisation O(1)
Itration O(n)
Test O(1)
Renvoi O(1)
Adition + affectation O(1)
Renvoie O(1)

La Complexite de la procedure :
O(1) + O(n) O(1) + O(1) = O(n)

21
Exemple :Recherche dichotomique 1/5

22
 Exemple : Complexit Recherche dichotomique 2/5

Le paramtre de complexit est la longueur du tableau, qu'on appelle n.

Cas au pire : x n'est pas dans le tableau. 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) soit t = log2 (n)

23
 Exemple : Complexit du tri bulle 5/5

Paramtre de complexit : la taille du tableau

Cas au pire : les lments sont tris dans l'ordre inverse de celui voulu
Complexit au pire : remonter le premier lment ncessite (n-1) tours de la
boucle imbrique, remonter le deuxime ncessite (n-2) tours, etc. Donc le
nombre de tours total est (n-1) + (n-2) + + 1 = n*(n-1)/2 soit O(n2 ).

Remarque : les tris par slection et par insertion sont aussi quadratiques.
Mais il existe des algorithmes de tri quasi-linaires.

24
 Exemples danalyse dalgorithmes rcursifs 1/3

Dterminez la complexit de la mthode suivante

Soit c(n) la nombre de multiplications effectues dans le calcul

de factoriel(n).
On a c(n)=c(n-1)+1, c(0)=1

25
 Exemples danalyse dalgorithmes rcursifs 2/3

Suite de Fibinacci :

F(n) = F(n-1) + F(n-2)

Analyse de la complexit c(n)=c(n-1)+c(n-2)+1

c(1)=c(0)=1

26
 Exemples danalyse dalgorithmes rcursifs 3/3

Thorme :
Soient a1 et b>1 deux constantes. Soient f(n) une fonction et T(n)
une fonction pour les entiers positifs qui vrifient une quation de
rcurrence de la forme
T(n) = aT(n/b) +f(n), soit k=logba , alors :
Si f(n)= O(nk-e) pour une constante e>0, alors T(n) = (nk).
Si f(n)= (nk) , alors T(n) = (nk log(n) ).
Si f(n)=( nk+e ) pour une constante e>0, et si af(n/b) < cf(n) pour
une constante c<1 alors T(n) = (f(n))

27
28