Université Protestante d’Afrique Centrale

Faculté des Technologies de

l’Information et de la Communication
Licence 1

CHAP 1: COMPLEXITÉ
ET
OPTIMALITÉ

Enseignante: Judith Nouho

1
 Complexité
 Exemple :
 problème : calculer xn
données : x : réel , n: entier
Méthode 1 : x0 = 1; xi = x* xi-1 i >0 T=n
Méthode 2 : x0 = 1;
xi = xi/2 * xi/2 , si i est pair; T = log n
xi = x*xi/2 * xi/2 si i est impair
...
résultats : y = xn
 Laquelle choisir? et pourquoi?
 Plutôt la deuxième.
=>Analyse de la complexité des algorithmes
2
Objectif de la complexité
 L'objectif premier d'un calcul de complexité algorithmique est de
pouvoir comparer l’efficacité d’algorithmes résolvant le même
problème. Dans une situation donnée, cela permet donc d'établir
lequel des algorithmes disponibles est le plus optimal.

 Si nous devons par exemple trier une liste de nombres, est-il

préférable d'utiliser un tri fusion ou un tri à bulles ?

 Ce type de question est primordial, car pour des données

volumineuses la différence entre les durées d'exécution de deux
algorithmes ayant la même finalité peut être de l'ordre de plusieurs
jours.

3
 Types de complexité
On distinguera deux sortes de complexité, selon que l'on s'intéresse au temps d'exécution ou
à l'espace mémoire occupé.

 Complexité en temps
-Réaliser un calcul de complexité en temps revient à décompter le nombre
d’opérations élémentaires (affectation, calcul arithmétique ou logique,
comparaison…) effectuées par l’algorithme.
-Pour rendre ce calcul réalisable, on émettra l'hypothèse que toutes les opérations
élémentaires sont à égalité de coût. En pratique ce n'est pas tout à fait exact mais
cette approximation est cependant raisonnable.
-On pourra donc estimer que le temps d'exécution de l'algorithme est
proportionnel au nombre d’opérations élémentaires.

 Complexité en espace
-La complexité en espace est quand à elle la taille de la mémoire nécessaire pour
stocker les différentes structures de données utilisées lors de l'exécution de
l'algorithme.
4
Analyse de la complexité :
 Complexité
Définition : La complexité d’un algorithme est la mesure du nombre
d’opérations fondamentales qu’il effectue sur un jeu de données.

 La complexité est exprimée comme une fonction de la taille du jeu de

données.

 Nous notons Dn l’ensemble des données de taille n et C(d) le coût de

l’algorithme sur la donnée d.

 Complexité au meilleur : Tmin(n) = min dDn C(d). C’est le plus petit

nombre d’opérations qu’aura à exécuter l’algorithme sur un jeu de données
de taille fixée, ici à n. C’est une borne inférieure de la complexité de
l’algorithme sur un jeu de données de taille n.
5
Analyse de la complexité :
 Complexité au pire : Tmax(n) = max dDn C(d). C’est le plus
grand nombre d’opérations qu’aura à exécuter l’algorithme sur
un jeu de données de taille fixée, ici à n.
 Avantage : il s’agit d’un maximum, et l’algorithme finira donc toujours
avant d’avoir effectué Tmax(n) opérations.

 Inconvénient : cette complexité peut ne pas refléter le comportement «

usuel » de l’algorithme, le pire cas pouvant ne se produire que très
rarement, mais il n’est pas rare que le cas moyen soit aussi mauvais que
le pire cas.

6
 Analyse de la complexité :
Complexité en moyenne : Tmoy(n) =  dDn C(d) / |Dn|
C’est la moyenne des complexités de l’algorithme sur des jeux de données
de taille n (en toute rigueur, il faut bien évidemment tenir compte de la
probabilité d’apparition de chacun des jeux de données).

Avantage : reflète le comportement « général » de l’algorithme si les cas extrêmes

sont rares ou si la complexité varie peu en fonction des données.

Inconvénient : la complexité en pratique sur un jeu de données particulier peut être

nettement plus importante que la complexité en moyenne, dans ce cas la
complexité en moyenne ne donnera pas une bonne indication du comportement
de l’algorithme.
En pratique, nous ne nous intéresserons qu’à la complexité au pire et à la
complexité en moyenne.
7
 Calcul de la complexité: algorithmes itératifs
 Algorithmes sans structures de contrôle
 Pour mémoire, une structure de contrôle est une structure itérative ou une structure
conditionnelle. Si un algorithme n'en comporte pas, pour évaluer sa complexité il suffit juste
de dénombrer le nombre d’opérations successives qu'il possède.

 Le cas des structures conditionnelles

 En présence d'une structure conditionnelle, il faut commencer par dénombrer le nombre de
conditions du test.
 On décompte ensuite le nombre d’opérations élémentaires de chacune des alternatives, et l'on
prend le maximum de ce décompte afin d'obtenir la complexité dans le pire des cas.

 Le cas des structures itératives

 Il y a deux possibilités lors du traitement d'une structure itérative.
 Si chaque itération comporte le même nombre d'opérations élémentaires, pour évaluer la
complexité il suffit de multiplier le nombre d'itérations par le nombre d'opérations de chacune
d'elles.
 Si chaque itération ne possède pas le même nombre d'opérations, il faudra alors distinguer
ces itérations, c'est-à-dire évaluer la complexité de chacune d'elle puis en faire la somme.
8
 Calcul de la complexité: algorithmes récursifs
 Récursivité simple

9
 Calcul de la complexité: algorithmes récursifs
 Algorithmes de type diviser pour régner:
 Un problème de taille n est ainsi divisé en a sous-problèmes de taille n/b, avec un coût f(n) pour
combiner les résultats de ces sous-problèmes.

10
Analyse de la complexité :
 Notation de Landau:
 On ne s ’intéresse pas en général à la complexité
exacte, mais à son ordre de grandeur.
=> besoin de notations asymptotiques.

11
 Analyse de la complexité :
 Exemples :
0 : n=O(n), (prendre n0 =1, c=1)
2n = O(3n) (prendre n0 =1 c = 2/3)
n2 - n-1 = O(n2) (prendre n0 = 1, c =1)

 : 1/2 n2 -3n =  (n2)

trouver n0 c1, c2 t.q.
c1 n2  1/2 n2 -3n  c2 n2
c1  1/2 -3/n  c2
la partie droite de l ’inéquation peut être satisfaite pour n0 = 1 et c2 = 1/2
la partie gauche de l ’inéquation peut être satisfaite pour n0 = 7 et c1 = 1/14
=> en choisissant n0 =7 , c1 =1/14, c2 = 1/2
=> 1/2 n2 -3n =  (n2)
….
12
Analyse de la complexité :
premier algorithme de tri
 Illustration : cas du tri par insertion
 Problématique du tri
données : une séquence de n nombre a1, a2, . . . , an.

résultats : une permutation <a ’1, a ’2, . . . , a ’n> des données t.q.
a ’1  a ’2 , . . . ,  a ’n

 exemple :

13
Analyse de la complexité : algorithme de tri
 Complexité
 attribution d ’un coût en temps ci à chaque instruction, et
 compter le nombre d’exécutions de chacune des instructions.
 Pour chaque valeur de j  [2..n], nous notons t j le nombre
d’exécutions de la boucle tant que pour cette valeur de j.
Il est à noter que la valeur de t j dépend des données…

 Le temps d’exécution total de l’algorithme est alors :

14
Analyse de la complexité : algorithme de tri
 Complexité au meilleur : le cas le plus favorable
pour l’algorithme TRI-INSERTION est quand le
tableau est déjà trié. Dans ce cas t j = 1 pour tout j.

 T(n) peut ici être écrit sous la forme T(n) = an + b, a

et b étant des constantes indépendantes des entrées, et
 T(n) est donc une fonction linéaire de n.
15
Analyse de la complexité : algorithme de tri
 Complexité au pire : le cas le plus défavorable pour
l’algorithme TRI-INSERTION est quand le tableau est déjà
trié dans l ’ordre inverse. Dans ce cas tj =j pour tout j.

Rappel : donc et
 T(n) peut ici être écrit sous la forme T(n)=ax2 +bx +c, a, b
et c étant des constantes, et T(n) est donc une fonction
16
quadratique.
Analyse de la complexité : algorithme de tri
 Complexité en moyenne : supposons que l’on applique
l’algorithme de tri par insertion à n nombres choisis au
hasard. Quelle sera la valeur de t j ? C’est-à-dire, où devra-
t-on insérer A[ j] dans le sous-tableau A[1.. j-1]? En
moyenne tj = j/2.
 Si l ’on reporte cette valeur dans l ’équation on obtient
également une fonction quadratique.
meilleur cas : Q(n).
pire cas : Q(n2).
en moyenne : Q(n2).
 En général, on considère qu’un algorithme est plus efficace
qu’un autre si sa complexité dans le pire cas a un ordre de
grandeur inférieur.
17
Classes de complexité
Les algorithmes usuels peuvent être classés en un certain nombre de grandes
classes de complexité :
– Les algorithmes sub-linéaires dont la complexité est en général en O(logn).

– Les algorithmes linéaires en complexité O(n) et ceux en complexité en

O(nlogn) sont considérés comme rapides.

– Les algorithmes polynomiaux en O(nk) pour k > 3 sont considérés comme lents,

- Les algorithmes exponentiels (dont la complexité est supérieure à tout

polynôme en n) que l’on s’accorde à dire impraticables dès que la taille des
données est supérieure à quelques dizaines d’unités.

18
Classes de complexité

O Type de complexité

O(1) constant

O(log(n)) logarithmique

O(n) linéaire

O(n×log(n)) quasi-linéaire

O(𝑛2 ) quadratique

O(𝑛3 ) cubique

O(2𝑛 ) exponentiel

O(n!) factoriel

19