Chapitre 7

COMPLEXITE ́ D’UN ALGORITHME

Mr A. GUEYE
gueyeabou17@gmail.com
+221 77 509 95 64
Objectifs
Le but de ce chapitre est de poursuivre l’analyse théorique d’un algorithme.
En implémentant un algorithme on peut se poser des questions par rapport à :

- Sa Terminaison : L’algorithme s’arrête-t-il un jour ? Donne-t-il un résultat ?

- Sa Correction : Est-ce qu’il fait bien ce qu’il est sens à faire ? (Sans
erreur sémantique)

- Sa Complexité : Quel est le temps d’exécution (raisonnable ou optimisé) ?

L’objet du chapitre est l’étude de la complexité :

En codant un algorithme, on souhaite minimiser le nombre « d’opérations »

effectuées lors de l’exécution de l’algorithme car le temps d’exécution est
proportionnel au nombre d’opérations et chaque ordinateur a une capacité
intrinsèque de calculs limitée (en constante progression avec la loi de
Moore).
I. Définitions
La complexité d’un algorithme est le prix à payer en termes de ressources
(opérations/stockage) pour mener à bien son exécution.

La complexité est la mesure de l’efficacité d’un programme pour un type de

ressources :

Complexité temporelle temps calcul CPU (processeur) : nombre

d’opérations é
́lémentaires réelisés par le processeur, ce qui est lié directement au
temps de calcul.

Complexité temporelle espace mémoire nécessaire : mémoire RAM / disque dur ...

Remarque En pratique, la complexité temporelle est plus importante que la

complexité spatiale car aujourd’hui la mémoire n’est généralement pas un probléme.

La complexité temporelle asymptotique est l’étude de l’ordre de grandeur de la

complexité pour des entrées de grande taille « dans le pire des cas » (lorsque la
variable entrée nécessite le maximum d’opérations dans chaque é
́tape de
l’algorithme).
I. Définitions
Compléxité C(n) (nombre d’opérations) en fonction de n(taille de la variable)

Remarque Très souvent on évalue la complexité d’algorithmes n’ayant qu’une

variable en entrée.
• On exprime la complexité en fonction de n,
la taille de l’entrée (longueur de la liste,
de la chaîne de caractères, de l’entier lui-même
ou bien du nombre de chiffres de l’entier entré).
• Les notations de Landau
(O(ln(n)), O(n), O(nk) ou` k ∈ N, O(2n))
sont les mieux adaptées pour exprimer cette
complexité.
Le tableau des n maximal pour un algorithme nécessitant f(n) opérations élémentaires
pour s’exécuter en moins d’une minute (en supposant 109 opérations élémentaires/second).
I. Définitions
Voici le temps d’exécution pour un problème de taille n = 106 sur un
ordinateur à 109 opérations par seconde :
II. Complexités des Commandes de Base
Toute ligne de code écrite comporte des commandes é
́lémentaires.
Chaque commande a sa propre complexité.
En général, leur exécution coûte O(1) en complexité (pas toutes)

Remarque

Ce n’est pas parce que la syntaxe d’une instruction

est courte qu’elle a une complexité en O(1) ! !

Pour de très grands entiers n, le temps d’exécution

de *,//,% est légérement plus é

́levé que +,-.

Néanmoins dans la pratique on ne compte qu’une « opération » pour chacune commandes.

De même, le temps d’exécution de ** sur les flottants est plus é

́levé que celui des
autres opérations (mais raisonnable grâce `a l’algorithme d’exponentiation rapide).
II. Complexité des commandes sur les listes
En Python, il est tout à fait possible faire des opérations sur tout une liste L à
l’aide d’un seule commande. Il faut avoir à l’esprit que ce ne sont pas des
opérations é
́lémentaires (elles ont chacune leur propre complexité), et certaines
cachent un travail important pour le processeur !
II. Complexité des commandes sur les listes
Remarque.
On préfèrera donc L.append(x) à L+=[x] et on évitera d’utiliser L.pop(i) alors que
L.pop() on peut.

Idem pour les tranches, ou les copies de listes, on évite si on peut faire autrement.
(Dans les algorithmes de tri par exemple.)

Les commandes analogues sur les chaînes de caractères ou dictionnaires ont la même
complexité.
Exemples
Exemples
Exemples
Supposons que nous disposons d’une fonction Moyenne(L) de complexité linéaire qui
renvoie la moyenne des éléments de la liste L.
On cherche à calculer la variance, calculer la complexité des deux algorithmes ci-
dessous.
Exemples
Algorithmes récursives :
il faut trouver, entre autre,
le nombre d’appels récursifs
à la fonction.
Exemple 1
Exemples
Exemple d’algorithme dichotomique
le tri fusion
Le but est de déterminer sa complexité.
Ici la taille n de l’entrée est la somme
des longueurs des listes G et D.
La complexité de Fusion est en O(n) donc linéaire.
En effet, les boucles en while va parcourir
les éléments de G et de D qui vont devoir tôt ou tard
être rajouté à la liste N au cours d’une des trois
boucles while.
A chaque fois il y a un ajout (append()) et une
variable qui augmente de 1.
Il y a aussi dans la 1ère boucle while une
comparaison. Il y a donc 3n opérations dans
le pire des cas.
IV. Complexité Spatiale
Une complexité spatiale est une mesure de l’espace mémoire maximal occupé
durant l’exécution de l’algorithme. On définit l’unité d’espace mémoire comme
la taille d’une structure de données particulières.

On mesure la complexité en espace par le nombre n d’unités de mémoire occupées

lors de l’exécution de l’algorithme.
V. Exercices
V. Exercices
V. Exercices
V. Exercices
V. Exercices
V. Exercices
V. Exercices
V. Exercices