⋆ NSI — Première ⋆ Lycée Édouard Branly ⋆ Complexité

Complexité d’un algorithme

1 Complexité d’un algorithme

Le calcul de la complexité d’un algorithme permet de mesurer sa performance. Il y a deux types de com-
plexité :
◮◮◮ complexité spatiale : permet de quantifier l’utilisation de la mémoire
◮◮◮ complexité temporelle : permet de quantifier la vitesse d’exécution
Remarque. ◮◮◮ Le calcul de la complexité temporelle permet de comparer l’efficacité d’algorithmes ré-
solvant le même problème. Cela permet d’établir lequel des algorithmes utilisés est le plus optimal.
◮◮◮ Pour des données volumineuses, la différence entre les durées d’exécution de deux algorithmes ré-
solvant le même problème, peut être de l’ordre de plusieurs jours.
◮◮◮ Le calcul de complexité en temps revient à compter le nombre d’opérations élémentaires (affecta-
tion, calcul arithmétique ou logique, comparaison · · · ) effectuées par l’algorithme.
◮◮◮ Les règles de calcul de complexité doivent être indépendantes :
◮◮◮ du langage de programmation utilisé
◮◮◮ du processeur de l’ordinateur
◮◮◮ de l’éventuel compilateur employé
Remarque. Nous supposons que toutes les opérations élémentaires sont à égalité de coût, soit 1 « unité »
de temps.

Exemple 1. Jade = Julien * 5 =⇒ 1 multiplication + 1 affectation =⇒ 2 " unités ".

Remarque. La complexité en temps d’un algorithme sera exprimé par une fonction, notée T (pour Time),
qui dépend :
◮◮◮ de la taille des données passées en paramètres : plus ces données seront volumineuses, plus il faudra
d’opérations élémentaires pour les traiter. On notera n le nombre de données à traiter.
◮◮◮ de la donnée en elle même, de la façon dont sont réparties les différentes valeurs qui la constituent.

2 Ordre de grandeur "asymptotique"

Règle 1 (Ordre de grandeur). Pour comparer des algorithmes, il n’est pas nécessaire d’utiliser la fonc-
tion T , mais seulement l’ordre de grandeur asymptotique, noté Θ (« grand tau»).
Une fonction T (n) est en O( f (n)) (« en grand Θ de f (n)« ) si :

∃n 0 ∈ N, ∃c ∈ R+ , ∀n ≥ n 0 =⇒ |T (n)| ≤ c | f (n)|
C’est à dire :
T (n) est en Θ( f (n)) s’il existe un seuil n 0 à partir duquel la fonction T est toujours dominée par la
fonction f , à une constante multiplicative fixée c près.

1
3 Classes de complexité
Θ Type de complexité
Θ(1) Constante
Θ(log(n)) logarithmique
Θ(n) linéaire
Θ(n × log(n)) quasi–linéaire
2
Θ(n ) quadratique
Θ(n 3 ) cubique
n
Θ(2 ) exponentielle
Θ(n!) factorielle

Exemple 2. ◮◮◮ T (n) = 2023 = Θ(1)

◮◮◮ T (n) = 3n + 7 = Θ(n)
◮◮◮ T (n) = 3 + 5(n − 2023) = Θ(n)
◮◮◮ T (n) = n(n + 1)(n + 2) + 2023 = Θ(n 3 )

4 Exemples de calcul de complexité d’un algorithme

4.1 Complexité d’un algorithme avec une boucle
Exemple

def fct(n):
s = 0
for i in range(1,n+1):
s += i

return s

print( fct(11) )

Ce qui correspond à la complexité suivante :

affectation : 1 (pour s)

itérations : au plus n (n affectations pour i)

opérations : n (n opérations s+i)
affectations : n (pour s)

Conclusion :
Ainsi, au total, il y a 3n + 1 opérations élémentaires, qui correspond à la complexité de la fonction. On dit
ici que la complexité est linéaire car T (n) = 3n + 1, c’est à dire que la complexité est en Θ(n).

2
4.2 Complexité d’un algorithme avec une boucle dans une autre
Exemple

def fctB(n):
s = 0
for i in range(1,n+1):
s += i

return s

def fctA(n):
P = 1
for j in range(1,n+1):
P *= fctB(j)

return P

print( fctA(10) )

On voit qu’il y a 1 première affectation (P = 1) puis, pour chaque valeur de j, il y a 1 affectation (pour la
variable j elle–même), suivie de 3j + 1 pour le calcul de fctB(j), 1 autre opération (le produit de P par fctB(j))
et enfin 1 affectation pour P.

Ce qui correspond à la complexité suivante :

1 affectation avant la boucle (P=1)

pour j = 1, il y a 1 (j) + [3 x 1+1] (fctB(1)) + 2 opérations élémentaires;

pour j = 2, il y a 1 (j) + [3 x 2+1] (fctB(2)) + 2 opérations élémentaires;

pour j = 3, il y a 1 (j) + [3 x 3+1] (fctB(3)) + 2 opérations élémentaires;

.
.
.
pour j = n, il y a 1 (j) + [3 x n+1] (fctB(n)) + 2 opérations élémentaires;

Conclusion :
La complexité totale est

n(n + 1) 3 2 11
n × 1 + 3(1 + 2 + 3 + · · · + n) + n × 1 + 2 × n = 4n + 3 × = n + n
2 2 2
Conclusion :
3 11
On dit ici que la complexité est quadratique car T (n) = n 2 + n est un polynôme de degré 2, c’est à dire
2 2
que la complexité est en Θ(n 2 ).
E XERCICE —A PPLICATION 1 (exercice de recherche).
Calculer la complexité de l’algorithme de la recherche dichotomique.