Complexité

Complexité
1. Définition de la complexité
Les algorithmes se caractérisent par la taille des données qu'ils manipulent et l'ensemble
des traitements qu'ils opèrent sur ces données.
ex de taille :
•nombres : le nombre lui même ou le nombre de bits (nb de chiffre en base 2)
•liste, tableau, matrice, . . . : La nombre d'éléments
•arbres : Nb de noeuds
•graphes : Nb de noeud et/ou nb d'arêtes
ex de traitement :
•affectations
•allocation mémoire (pour l'espace)
•comparaisons
•arithmétique ,. . .
Pour un même problème, les algorithmes qui le résolve se classent selon leur complexité.
Définition (complexité) : 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.
Soit Dn l'ensemble des données de taille n et T(d) le coût de l'algorithme sur la donnée d.
Complexité au meilleur : Tmin(n) =
mind∈DnTd
: plus petit nombre d'opérations
qu'aura à exécuter l'algorithme sur un jeu de données de taille n. C'est la borne inférieure
de la complexité de l'algorithme sur un jeu de données de taille n.
Complexité au pire : Tmax(n) =
maxd∈DnTd
: plus grand nombre d'opérations qu'aura à
exécuter l'algorithme sur un jeu de données de taille n.
Complexité en moyenne : Tmoy(n) =
∑
d∈Dn
pdTd
: moyenne des complexités pour les
données de taille n avec p(d) la probabilité de voir apparaître la donnée d.
Attention : les complexités au meilleur et au pire ne sont que des indications, elles
montrent les limites au dessus et en deça desquelles l'algorithme n'ira pas. La complexité
en moyenne montre le comportement général de l'algorithme et ne donne une bonne

mesure que si le coût varie peu avec les données et si les cas extrêmes sont rares.
Dans la pratique on s'intéresse à la complexité au meilleur et au pire.
Définition (optimalité) : Un algorithme est dit optimal si sa complexité est la complexité minimale
parmi les algorithmes de sa classe.
2. Exemple : le tri insertion
•principe : n éléments, dans un tableau T, indicés de 1 à n. On considère que les
éléments de 1 à j-1 sont triés (donc au départ j = 2). On insère le jième élément à la
bonne place par décalage.
•Algorithme :
Tri Insertion coût fois
pour j=2 à longueur(T) c1n *
v = T[j] c2n-1
i = j-1 c3n-1
tant que i>0 et T[i] > v c4
∑
j=2
n
tj
**
T[i+1] = T[i] c5
∑
j=2
n
tj−1
i=i-1 c6
∑
j=2
n
tj−1
T[i+1] = v c7n-1
* une affectation de plus pour le test de sortie de boucle (lorsque j = longueur(T)+1)
** tj correspond au nombre de fois que le test de la boucle tant que s'exécute (compris entre
1 et j).
•Le coût total
Tn
est donc :
Tn=c1nc2c3c7n−1c4∑
j=2
n
tjc5c6∑
j=2
n
tj−1
au meilleur (si le tableau est trié) :
tj
vaut toujours 1
Tn=c1nc2c3c7c4n−1=c1c2c3c4c7n−c2c3c4c7
au pire, lorsque le tableau est trié dans l'ordre décroissant,
tj=j
, on sait que :

∑
j=2
n
j=nn1
2−1
et
∑
j=2
n
j−1= nn−1
2
donc :
Tn=c1nc2c3c7n−1c4
nn1
2−1
c5c6
nn−1
2
d'où :
Tn= 1
2c4c5c6n2c1c2c3c4 2−c5 2−c6 2c7n−c2c3c4c7
T(n) est de la forme
an2bnc
, c'est donc une fonction quadratique de n.
en moyenne : en moyenne, lors de l'insertion de l'élément v, il y a , dans la partie triée,
autant d'éléments supérieurs à v que d'éléments inférieurs à v et donc que
tj=j/2
. Cela
conduit à une complexité quadratique similaire à celle du pire cas avec des facteurs ¼ au
lieu de ½.
La complexité en moyenne est parfois difficile à établir. Le cas « au pire » ou « au mieux »
est souvent représenté par une seule configuration qu'il convient alors d'examiner. Pour le
cas moyen, toutes les configurations doivent être considérées. Pour éviter une démarche
exhaustive, un étude probabiliste ardue doit parfois être menée.
3. Notations
•Pour
n∈ℕ
gn={ fn ∣ ∃c1, c20et n0tel que 0c1gn fnc2gn ∀ nn0}
•Une fonction f(n) appartient à
gn
si elle peut être, à partir d'un certain n0,
encadrée par deux fonctions qui sont des multiples de g(n).
•On dit que g(n) borne asymptotiquement f(n). On note abusivement
fn= gn
pour dire
fn∈ gn
.
exemple 1 : montrons que
2
3n21 2n=n2
on doit déterminer trois constantes
n1, n2, c0
avec
c1n22
3n21 2nc2n2
pour
nn0
divisons par n2 :
c12
31 2nc2
•On peut par exemple choisir c1 = 2/3, n0 = 3, d'où l'on déduit que l'inégalité fonctionne
pour c2 = 5/6.
exemple 2 : montrons que n3 ≠
n2
.
c1n2n3c2n2
en divisant par n2 il vient

c1nc2
on peut choisir c1 = 1 mais aucune constante n2 ne peut convenir car n est
arbitrairement grand.
•Pour donner une borne supérieure ou inférieure asymptotique, on utiliser les notations
:
Ogn={ fn ∣ ∃c0et n0tel que 0fnc g n ∀ nn0}
(borne supérieure)
Ωgn={ fn ∣ ∃c0et n0tel que 0c g n fn ∀ nn0}
(borne inférieure)
4. Usages
•Nous nous intéressons quasi exclusivement à la complexité en temps des algorithmes.
Il est parfois intéressant d'observer la complexité en espace mémoire, en bande
passante requise, etc.
•Pour que les résultats de l'analyse d'algorithme soit comparable, il faut avoir un
modèle de la machine sur laquelle l'algorithme sera implémenté. On prendra comme
référence un modèle de machine à accès aléatoire et à processeur unique où les
opérations sont exécutées l'une après l'autre sans opérations simultanées.
•Une complexité est généralement donnée en ordre de grandeur, lorsque n devient
grand, les termes les moins significatifs sont négligés. Ainsi pour le tri par insertion, on
notera :
- meilleur cas :
n
- pire cas :
n2
- en moyenne :
n2
•Les algorithmes sont en général comparés sur leur complexité au pire, aussi celle-ci est
donné en O(f(n)).
•Classes de complexité :
–constant :
O1
On rencontre cette complexité quand toutes les instructions sont exécutées une
seule fois qu'elle que soit la taille n du problème.
–sub-linéaire :
Olog n
Ce cas de figure se rencontre quand la taille du problème est divisée
par une entité constante à chaque itération (ex : recherche dichotomique)
–linéaire :
On
boucle de 1 à n et le corps de la boucle effectue un travail de durée constante et
indépendante de n.
Onlog n
algorithmes quasi-linéaires où à chaque itération la taille du problème est
divisée par une constante avec à chaque fois un parcours linéaire des données.
–polynomiale :
Onk
concerne des algorithmes considérés comme lents lorsque k
> 3. boucles imbriquées chacune allant de 1 à n
–exponentielle :
Okn
pour k >= 2 donné, concerne des algorithmes considérés

comme impraticables (exemple : 2n pour les tours de Hanoï)
–factorielle :
On !
n
log2n
nlog2n
n2
n3
2n
10 0 1 1 2
10 3,32 33,2 100 1 000 1 024
100 6,64 664 10 000
106
1,26×1030
1 000 9,965 9965 1 000 000
109
∞
(
101000log102
=
10300
)
1 000 000 19;931 19 931 568
1012
1018
∞
10929,89 29897352854 1018 1027
∞
2n
(x 2)
~+1
(=> si 2x plus
de données,
on ajoute une
opération)
x2 + 2n
≈ x2
x 4 x 8 carré
Si 109 opérations par secondes
n
log2n
nlog2n
n2
n3
2n
100
10-6 s 10-5 s
10−3
s
400×109
siècles
1 000 10-8 s 10-5 s 10-3 s 1 s
∞
1 000 000 2 x 10-8 s 2 x 10-2 s 103 s = 16,6
min
31 ans
∞
1093 x 10-8 s 30 s 109 sec = 31
ans
31 x 109
années
∞
5. Dernier exemple : tri rapide
écrire algorithme
complexité partition : O(n)
au pire : n appels à partition => O(n2)