Chapitre 1 : La complexité des algorithmes

Chapitre 1 : La complexité des algorithmes

1- Introduction

Evaluer la complexité d'un algorithme consiste à évaluer le temps d’exécution d’un algorithme.
Pour être tout à fait correct, on n’évalue pas le temps d’exécution, mais plutôt le nombre
d’opérations effectuées. Une fois le nombre d’opérations connu, on peut donner une évaluation
du temps en fonction des performances de la machine. En d'autres termes il s'agit de déterminer
quelle sera, dans l'expression du temps de calcul d'un algorithme, le terme

∞.
Ai = f (n)/ tels que : tous les autres termes Aj≠i soit négligeable devant Ai pour n = +∞

Cette recherche de la complexité d'un algorithme se fait dans le pire des cas, c'est à dire que
l'arrangement des données du problème, bien qu'aléatoire, pousse l'algorithme dans ses 'limites'.

2- Cas introductif

En mathématiques, les notations O() et o() ont la même signification. On considère l’algorithme
suivant :

Algorithme 1 : Recherche d’un élément dans une liste

On considère L = [5; 1; 2; 4; 6; 7].

1. Quel est le nombre d’opérations effectuées par l’algorithme de recherche avec les entrées
L et X= 5 ?
2. Quel est le nombre d’opérations effectuées par l’algorithme de recherche avec les entrées
L et X= 7 ?
3. Quel est le nombre d’opérations effectuées par l’algorithme de recherche avec les entrées
L et X= 3 ?

Entrées : une liste L[1::n]

un élément X
Sorties : un booléen
i ←1
tant que i < n et L[i] ≠ X faire
i← i+1
fin tant que
si i < n alors
retourner Vrai
sinon
retourner Faux
fin si

1
Chapitre 1 : La complexité des algorithmes

3- Type de complexité

Pour un algorithme d’entrée E (E peut éventuellement être un ensemble d’entrées) :

a. on appelle complexité dans le meilleur cas le nombre minimal d’opérations effectuées par
l’algorithme sur une entrée de taille n.
b. On appelle complexité dans le pire cas le nombre maximal d’opérations effectuées par
l’algorithme sur une entrée de taille n.
c. On appelle complexité en moyenne le nombre moyen d’opérations effectuées par
l’algorithme sur l’ensemble des entrées de taille n.
4. Dans l’algorithme précédent, quel est le nombre minimal d’opérations effectuées avec en
entrée une liste de taille n ? Dans quels cas est-il atteint ?
5. Dans l’algorithme précédent, quel est le nombre maximal d’opérations effectuées avec en
entrée une liste de taille n ? Dans quels cas est-il atteint ?
6. On suppose que l’on sait que l’élément se trouve dans la liste. Quel est le nombre moyen
d’opérations effectuées par l’algorithme pour des listes de taille n ? (on suppose les
positions équiprobables)
7. On suppose maintenant que l’élément a une chance sur deux de se trouver dans la liste.
Quel est le nombre moyen d’opérations effectuées pour des listes de taille n ?
4- Définition

O(f(n)) est un ensemble de fonctions, dont la croissance est inférieur ou égale à celle de f(n).
Plus formellement, on a :
O(f(n)) = { t : N→R* / ∃ c ∈ R+ , ∃ n0 ∈ N, ∀n ≥ n0 : t(n) ≤ c f(n) }
Exemples :

n2 ∈ O(n2)
n2 ∈ O(n3) car n2 ≤ c* n3 pour c = 1 et n ≥ 0 = n0
2n+1 ∈ O(2n) car 2n+1 = 2*2n ≤ c*2n pour c ≥ 2 et n ≥ 0 = n0
3n ∉ O(2n) car (3/2)n est croissante. Donc il n’existe pas de constante supérieure ou égale
à (3/2)n pour toute valeur de n.
(n+1)! ∉ O(n!) car (n+1)!/n! = n+1 qui est croissante
logbn ∈ O(logan) car logbn = (1/ logab)*logan et 1/ logab est une constante
5- Règles de calcul de la complexité

On calcul le temps d’exécution, mais on effectue les simplifications suivantes :

2
Chapitre 1 : La complexité des algorithmes

On oublie les constantes multiplicatives (elles valent 1)

On annule les constantes additives
On ne retient que les termes dominants

Exemple (simplifications) soit g(n) = 4n 3 - 5n 2 + 2n + 3

• On remplace les constantes multiplicatives par 1 : 1n 3 - 1n 2 + 1n + 3

• On annule les constantes additives : n 3 - n 2 + n + 0
• On garde le terme de plus haut degré : n 3+ 0
• On a donc: g(n) = O(n3)

5.1. Justification des simplifications

Les processeurs actuels effectuent plusieurs milliards d’opérations à la second :

• Une affectation requière 2 ou 4 unités de temps ne change donc pas grand-chose

D’où le remplacement des constantes par des 1 pour les multiplications
• Un nombre constant d’instruction est donc aussi négligeables par rapport à la croissance
de la taille des données
D’où l’annulation des constantes additives
• Pour de grandes valeurs de n, le terme de plus haut degré l’emportera
D’où l’annulation des termes intérieurs

5.2. Combinaison de complexité

• Les instructions de base prennent un temps constant, noté O(1). On dit qu’une instruction
élémentaire s’effectue en temps constant. Les instructions élémentaires utilisées ici :
l’affectation d’une valeur à une variable entière ;
la comparaison de deux valeurs entières (avec < et ==) ;
l’incrément d’une valeur entière ;
l’accès au i-ème élément d’une liste ;
lecture et écriture
le renvoi d’une valeur booléenne.

• La complexité d’une séquence d’instructions P et Q est O(P) + O(Q). En effet, si O(P) est
la complexité du bloc P et si O(Q) est la complexité du bloc Q, alors O(P) + O(Q) est la
complexité de la séquence d’opérations de P et Q.
• Même chose pour les branchements conditionnels :

Si <condition> Alors O(g(n))

Instructions (1) O(f1(n))
Sinon = O(g(n)) + Max(O(f1(n)), O(f2(n))
Instructions (2) O(f2(n))
Finsi
• Dans les boucles, on multiplie la complexité du corps de la boucle par le nombre d’itération :
Par exemple : La complexité d’une boucle tant que se calcule comme suit

3
Chapitre 1 : La complexité des algorithmes

Tant que <condition> faire O(g(n))

Instructions O(f(n)) = O(m*(g(n) + f(n)))
FinTantQue

5.3. Etapes de calcul de la complexité

Pour calculer la complexité d’un algorithme :

1. On calcule la complexité de chaque partie de l’algorithme

2. On combine ces complexités conformément aux règles qu’on vient de voir
3. On simplifie le résultat grâce aux règles de simplifications vues ci-dessus.

6- Classes de complexité
1. On peut ranger les fonctions équivalentes dans la même classe.
2. Deux algorithmes appartenant à la même classe sont considérés de même complexité.
3. Ci-dessous, nous citons les complexités usuelles les plus rencontrées dans l’analyse des
algorithmes. Elles sont classées de la plus forte à la plus faible.
• O(1) → Constante
• O(log n) → Logarithmique
• O(n) → Linéaire
• O(n2) → Quadratique
• 3
O (n ) → Cubique
• k
O(n ) → Polynomiale (avec k une constante)
• O(n!) → Factrielle
• O(an), O(nn),.. → Exponentiel (avec a une constante)

Exemple : Le tableau ci-dessous donne une illustration du temps d’exécution par rapport à la
complexité des algorithmes tel que : n varie de 5 à 1000000.