CHAPITRE 2

Complexité et optimalité

2.1 Introduction

La complexité était développée dans le but de comparer efficacement différents algorithmes

entre eux, afin de savoir lequel était le meilleur pour un problème donné.

La complexité des algorithmes est l’évaluation du coût d’exécution d’un algorithme en

termes de temps (complexité temporelle) ou d’espace mémoire (complexité spatiale). Dans ce
qui suit on va s’intéresser à la complexité en temps d’exécution.

2.2 Modèle de machine

Le temps d’exécution d’un algorithme dépend de la machine sur laquelle s’exécute

l’algorithme, de la traduction de l’algorithme en langage exécutable par la machine. Mais nous
ferons ici abstraction de ces deux facteurs, pour se concentrer sur le coût des actions résultant
de l’exécution de l’algorithme, en fonction d’une “taille” n des données traitées. Ceci permet
en particulier de comparer deux algorithmes traitant le même calcul.

Pour que le résultat de l’analyse de la complexité d’un algorithme soit pertinent, il faut avoir
un modèle de machine sur laquelle l’algorithme sera implémenté (sous forme de programme).
On prendra comme référence un modèle de machine à accès aléatoire (RAM) et à processeur
unique, où les instructions sont exécutées l’une après l’autre, sans opérations simultanées.

2.3 Définition Complexité (temporelle) des algorithmes

La complexité d'un algorithme est le nombre d'opérations élémentaires (affectations,

comparaisons, opérations arithmétiques …) effectuées par un algorithme.

Formellement, l’expression d’une complexité prend la forme d’une fonction mathématique

en fonction de la taille n des données.

Exemples :
- Si le tri du tableau a une complexité 𝑓(n) =𝑎𝑛+𝑏, on dira que le tri possède une
complexité linéaire.
- Si un autre algorithme de tri possède une complexité 𝑓(n) =𝑛2, alors on considèrera
que ce tri a une complexité quadratique.

1
 2.4 Objectifs de calcul de la complexité
1. Pouvoir prévoir le temps d'exécution d'un algorithme
2. Pouvoir comparer deux algorithmes réalisant le même traitement

2.5 Cas de complexité

1. Complexité au pire : temps d'exécution maximum, dans le cas le plus défavorable.
2. Complexité au meilleur : temps d'exécution minimum, dans le cas le plus favorable
(en pratique, cette complexité n'est pas très utile).
3. Complexité moyenne : temps d'exécution dans un cas médian, ou moyenne des temps
d'exécution.

Le plus souvent, on utilise la complexité au pire, car on veut borner le temps d'exécution.

2.6 Approximations de la complexité

Les complexités algorithmiques théoriques sont toujours des approximations :

1. Première approximation : on ne calcule que la forme générale de la complexité

2. Deuxième approximation : on ne considère souvent que la complexité au pire
3. Troisième approximation : on ne regarde que le comportement asymptotique de la
complexité car le temps de calcul ne pose pas de problème lorsqu’on traite des
données peu volumineuses.

2.7 Notation asymptotique

Lors de l’évaluation de la complexité d’un algorithme, on s’intéresse généralement à son

ordre de grandeur asymptotique et on utilise les notations de landau suivantes :
O : f = O(g) <=> Ǝ n0 > 0, Ǝ c≥ 0, ∀𝑛 ≥ 𝑛0 , f (n) ≤c* g(n) (g est une borne supérieure
asymptotique de f).
 : f = (g) <=> Ǝ n0 > 0, Ǝ c≥ 0, ∀𝑛 ≥ 𝑛0 , f (n) ≥ c* g(n) (g est une borne inferieure
asymptotique de f).
o : f = o(g) <=>∀𝑐 ≥ 0, ∃𝑛0 > 0, ∀𝑛 ≥ 𝑛0 , f (n) ≤ 𝑐 ∗ 𝑔(𝑛).
 : f = (g) <=> f = O(g) et g = O( f ) (g est une borne approchée asymptotique de f).
Pour comparer des algorithmes, il n’est pas nécessaire d’utiliser la fonction de complexité T,
mais seulement l’ordre de grandeur asymptotique.
Exemple 1 : Illustration de f(n) = O(g(n))
f(n) = O(g(n)) : f(n) est en O(g(n)) (en grand O de g(n) ) s’il existe un seuil n0 à partir duquel la
fonction f est toujours dominée par la fonction g, à une constante multiplicative fixée c près.

2
 Figure : Comportement asymptotique 𝑛 → ∞
Exemple 2 :

soient 𝑓 (𝑛) = 𝑛2 − 180𝑛 + 144 𝑒𝑡 𝑔(𝑛) = 𝑛2

Nous avons 𝑓 (𝑛) = 𝑂(𝑔(𝑛))
En effet ∃ (𝑐 = 182 > 0 )𝑒𝑡 (∃ 𝑛0 = 12 > 0) 𝑡𝑒𝑙𝑠 𝑞𝑢𝑒: 𝑓 (12) ≤ 182 ∗ 𝑔(12) .

2.8 Efficacité d’un algorithme

On considère généralement qu’un algorithme est plus efficace qu’un autre si son temps
d’exécution dans le cas le plus défavorable a un ordre de grandeur inférieur.

2.9 Classes de la complexité

Un algorithme A est dit de complexité :

✓ constante si complexité(A) = O(1)

✓ logarithmique si complexité(A)=O(log(n))
✓ linéaire si complexité(A) = O(n)
✓ quadratique si complexité(A) = O(𝑛2 )
✓ polynomiale si complexité(A) = O(𝑛𝑘 ) pour k ≥ 3
✓ exponentielle si complexité(A) =O(en)

2.10 Exemple Tri par insertion

Notons :
ci: le coût en temps d'exécution d'une instruction i
t j: nombre d’exécutions de la boucle tant que pour la valeur j

3
 Algorithme tri_insertion ; Coût Nombre
Var n, i, j, x : entier; d’itérations
A: tableau;
Debut
Pour j allant de 2 à n faire c1 n
debut pour
x ← A[j]; c2 n-1
i← 𝑗 − 1; c3 n-1
𝑛
tant que i > 0 et A[i] > x faire c4 ∑ 𝑡𝑗
𝑗=2
debut tant que 𝑛
∑ (𝑡𝑗 − 1)
𝑗=2
A[i+1] ← A[i]; c5
𝑛

c6 ∑ (𝑡𝑗 − 1)
i← i-1; 𝑗=2

fintant que

A[i+1] ← x; c7
n-1
Finpour
Fin

Complexité

T(n) = c1* n +c2 *(n-1)+ c3 *(n-1) +c4 ∗ ∑nj=2 tj + c5 ∗ ∑nj=2(tj − 1) + c6 ∗ ∑nj=2(tj − 1) +

c7 * (n − 1)

1. Complexité au meilleur cas (tableau trie)

tj=1

T(n) = c1* n +c2 *(n-1)+ c3 *(n-1) +c4 ∗ (n − 1) + c7 * (n − 1)

= (c1+c2+c3+c4)*n- (c2+c3+c4+c7)
= An+B

La complexité est d’ordre O(n).

2. Complexité au pire cas (tableau trié dans l’ordre inverse)

𝑛(𝑛+1) 𝑛(𝑛−1)
tj=j donc ∑nj=2 j = 2 − 1 et ∑nj=2(j − 1) = 2

4
 𝑛(𝑛+1)
T(n)= c1* n +c2 *(n-1)+ c3 *(n-1) +c4 ∗ ( − 1 ) + c5 ∗
2
𝑛(𝑛−1) 𝑛(𝑛−1)
+ c6 ∗ + c7 * (n − 1)
2 2

𝑐4 𝑐5 𝑐6 𝑐4 𝑐5 𝑐6
T(n)= ( 2 + + )n2 +(𝑐1 + 𝑐2 + 𝑐3 + − − + 𝑐7)n-
2 2 2 2 2

(c2+c3+c4+c7)
= An2 + Bn+ C
La complexité est d’ordre O(n2 ).

3. Complexité au moyen cas

tj=j/2

La complexité est d’ordre O(n2 ).