Mathématiques Discrètes et Algorithmique - LMPT

Université François Rabelais de Tours
Laboratoire de Mathématiques et Physique Théorique
Mathématiques Discrètes et Algorithmique
UE 5-4 Option Semestre 5
3. Complexité
La théorie de la complexité vise à savoir si la réponse à un problème peut être donnée efficacement ou, au
contraire être inatteignable en pratique. Pour cela, elle se fonde sur une estimation théorique des temps
de calcul et de la mémoire utilisée. Nous ne considérerons ici que l’estimation du temps de calcul. Il y en
a deux types :
•Etude du cas le plus défavorable : On estime le nombre d’opérations nécessaires à la complétion de
l’algorithme dans le pire des cas (on supposera toujours que le nombre de boucles est maximum)
•La complexité en moyenne : On estime le nombre moyen d’opérations nécessaires à la complétion de
l’algorithme en fonction de toutes les entrées possibles.
La complexité en moyenne est beaucoup plus difficile à calculer que l’autre. Nous nous concentrerons sur
la complexité dans le cas le plus défavorable.
Exemple 3.1. Considérons l’algorithme suivant qui détermine si l’élément xappartient à la liste Let si
oui, renvoie sa position.
Données : Liste (a1, a2, . . . , an),x
position := 0
i:= 1
pour i= 1 ànfaire
si x=aialors
retourner position := i
fin
fin
Résultat :position
Algorithme 8: Recherche d’un élément
Lorsque l’on écrit "retourner", cela signifie que l’algorithme s’arrête (on sort de la boucle pour) et renvoie
la valeur.
Complexité dans le pire des cas. A chaque étape de la boucle pour, on effectue 1 comparaisons. Dans
le pire des cas, c’est à dire si on parcourt la boucle n-fois, on aura fait ncomparaisons.
Complexité en moyenne Si xest le premier terme, 1 comparaisons sont nécessaires. Si xest en se-
conde position, 2 comparaisons sont nécessaires. En général, si xest en iième-position, on a besoin de i
comparaisons. Le nombre moyen de comparaison est donc
1+2+3+. . . +n
n=n+ 1 2
3.1. Comparaison de fonctions.
Définition 3.2. Soient f, g :R−→ R(ou N−→ R). On dit que fest O(g)si et seulement si il existe des
constantes C, k ∈Rtelles que
|f(x)| ≤ C|g(x)|pour tout x>k
On écrira quelque-fois f=O(g)ou encore f(x) = O(g(x)). On dit que Cet ksont les témoins de la
relation f=O(g).
Intuitivement, cette relation dit que fgrandit plus lentement qu’un multiple de g.
Exemple 3.3. Montrons que la fonction f(x) = x2+ 2x+ 1 est O(x2). Lorsque x > 1, on a
0≤x2+ 2x+ 1 ≤x2+ 2x2+x2= 4x2.
Par conséquence, si on choisit C= 4 et k= 1, on voit que f=O(x2).
1

2
On peut être plus précis. En effet, pour x > 2, on a 2x<x2et 1< x2. Ainsi
0≤x2+ 2x+ 1 ≤x2+x2+x2= 3x2
et on peut choisir C= 3 et k= 2.
En fait, il est possible de montrer que pour tout C > 1, il existe k∈Rtel que
0≤f(x)≤Cx2pour tout x>k
On a la caractérisation suivante.
Théorème 3.4. On a f(x) = O(g(x)) si et seulement si
lim sup
x→+∞
|f(x)
g(x)|<∞
En particulier, si lim
x→+∞
|f(x)
g(x)|<∞alors f(x) = O(g(x)).
Corollaire 3.5. Soit f(x) = anxn+. . . +a1x+a0où ai∈Rpour tout 1≤i≤n. On a f(x) = O(xn).
Exemple 3.6. (1) Montrons que Sn:= Pn
i=1 iest O(n2). On a pour tout n≥1
Sn=1+2+. . . +n≤n+n+. . . +n=n2
Ainsi, Sn=O(n2). On aurait aussi pu montrer que Sn=n(n+1)
2.
(2) On cherche un grand-Ode factorielle n. On rappelle que n! = n·(n−1) . . . 2·1. On a
n! = n·(n−1) . . . 2·1≤n·n...n=nn
On a donc n! = O(nn).
(3) Montrons que log n=O(n). On utilise le Théorème 3.4. On a
lim
n→∞
log(n)
n= 0
et le résultat suit.
La figure suivante illustre à quelle vitesse les différentes fonctions croissent.

3
Théorème 3.7. Soient f1, f2, g1, g2, g, f des fonctions réelles. On a
i) Si f1=O(g1)et f2=O(g2)alors f1+f2=O(g1+g2)
ii) Si f1=O(g1)et f2=O(g2)alors f1·f2=O(g1·g2)
iii) Si f1=O(g)et f2=O(g)alors f1+f2=O(g).
Définition 3.8. Soient f, g :R−→ R(ou N−→ R). On dit que
•fest Ω(g)si et seulement si il existe des constantes C, k ∈Rtelles que
|f(x)| ≥ C|g(x)|pour tout x>k
•fest Θ(g)si et seulement si f=O(g)et f= Ω(g). En d’autres termes, f= Θ(g)si et seulement si il
existe des constantes C1, C2, k telles que
C1g(x)≤ |f(x)| ≤ C2|g(x)|pour tout x>k
3.2. Exemples d’étude de complexité.
Exemple 3.9. Considérons l’algorithme suivant pour déterminer le maximum d’une liste d’entiers.
Données : Liste d’entiers L: (a1, a2, . . . , an)
max := a1
pour i= 2 ànfaire
si max < aialors
max := ai
fin
fin
Résultat :max Algorithme 9: Recherche du maximum dans une liste
Nous allons calculer la complexité de cet algorithme en terme de nombre de comparaisons, puisque c’est
l’opération élémentaire utilisée dans cet algorithme. La boucle "pour" est parcourue n−1fois, à chaque
fois il y a un test max < ai, on a donc fait n−1comparaisons.
Exemple 3.10. On rappelle l’algorithme du tri à bulle.
Données : Liste d’entiers L: (a1, a2, . . . , an)
Résultat : Liste triée
pour i=1 àn-1 faire
pour j=1 àn-i faire
si aj> ajalors
échanger ajet aj+1
fin
fin
fin
Le nombre de comparaisons pour mener à bien cet algorithme est
(n−1)
| {z }
boucle i= 1
+ (n−2)
| {z }
boucle i= 2
+. . . + 1 = n(n−1)
2ce qui est Θ(n2).
Exemple 3.11. On rappelle l’algorithme du tri par insertion.
Données : Liste d’entiers L= (a1, a2, . . . , an)
Résultat : Liste d’entier triée
pour i=2 ànfaire
j:= i;
tant que j > 1et aj−1> ajfaire
Echanger ajet aj−1;
j:= j−1
fin
fin
retourner LAlgorithme 10: Tri par insertion

4
Encore une fois, déterminons le nombre de comparaison nécessaire pour mener à bien cet algorithme.
Cet algorithme insère le jième élément à la bonne position parmi les j−1premiers (qui sont, eux, déjà
triés). Cette insertion est faite de manière linéaire : on compare successivement ajavec les ai, i ≤j−1
jusqu’à qu’un des éléments soient plus grand que aj. Dans le pire des cas, l’insertion coûte jcomparaisons.
Finalement, le nombre de comparaisons est :
2 + 3 + . . . +n=n(n+ 1)
2−1
Ce qui est Θ(n2).
Remarque 3.12.Il est important de noter que cet algorithme peut utiliser beaucoup moins de comparaisons
dans des cas plus favorables !
Exemple 3.13. On rappelle que l’algorithme d’Euclide pour déterminer pgcd(a, b). On calcule successi-
vement
a=bq1+r1
b=r1q2+r2
r1=r2q3+r3
. . .
rk=rk+1qk+2 +rk+2
Le dernier reste non nul est alors le pgcd rechercher. Déterminons le nombre de divisions nécessaires. Tout
d’abord on voit facilement que la suite des restes est strictement decroissante. Montrons que pour tout j,
on a rj+2 <1
2rj. Si rj+1 <1 2rjalors c’est clair. Si rj+1 ≥1 2rjalors
rj=rj+1 ·1 + rj+2
et rj+2 =rj−rj+1 <1
2rj. Soit `tel que 2`−1≤a < 2`. Toutes les deux etapes, le reste est divisée par
deux, ainsi il y a au plus 2·log2(a)divisions.
3.3. Comprendre la complexité des algorithmes. Un algorithme est dit de complexité polynomiale si
il est Θ(nb)pour un certain b∈N∗. Par exemple, le tri à bulle est de complexité polynomiale, nous avons
vu qu’il est d’ordre Θ(n2).
Dire qu’un algorithme est d’ordre Θ(n2)doit se comprendre de la manière suivante. Si, on lui donne en
entrée, un élément de taille n, l’algorithme va effectuer un nombre d’opérations de la forme Cn2pour une
constante C. Si on lui donne un argument de taille 2n, il va effectuer C(2n)2= 4.Cn2et donc prendre
4 fois plus de temps. De la même manière un algorithme Θ(n3)mettra 8 fois plus de temps pour un
argument de taille 2nque pour un argument de taille n. Le tableau suivant donne une idée plus précise de
ce phénomène. Le temps d’une opération est estimé à 10−11 seconde.
En cryptographie, il n’est pas rare d’avoir des arguments de taille de l’ordre de 10150. On imagine alors
aisément le besoin d’avoir des algorithmes efficaces ! ! !