Vous êtes sur la page 1sur 8

II.

Complexité
1. Définitions

Algorithme :

Un algorithme est une séquence (suite) d’étapes de calcul qui transforment un ensemble de
valeurs d’entrée en sortie.
Complexité d’un algorithme :

C’est le nombre d’opérations élémentaires que l’algorithme doit effectuer pour mener à bien
un calcul en fonction de la taille des données d’entrée.
Complexité d’un problème :

La complexité d’un problème est la complexité du meilleur algorithme qui résout ce


problème.

L’efficacité d’un algorithme est mesurée par l’augmentation du temps de calcul en fonction
du nombre des données.
Nous avons donc deux éléments à prendre en compte :
• La taille des données.
• Le temps de calcul.

Pour connaitre le temps de calcul, nous calculons le nombre d’opérations fondamentales


exécutées par l’algorithme.

2. Coût d’opérations

Séquence: T( n)=ΣTi(n)
Alternative :
Si C alors
J
Sinon
K
Fin si

T (n)=TC( n)+max {TJ(n) ,TK(n)}

10
Itération bornée :
Pour i de j à k faire
B
Fin pour

T(n)=(k− j+1)* TB(n)

Itération non bornée :


Tant que C faire
B
Fin Tant que

T(n)=Nbboucles * (TB(n)+ TC(n)) + TC(n)

Répéter B
Jusqu’à C

T (n)=Nbboucles *( TB(n)+ TC(n))

Exemple : multiplication de deux matrices :


entrée : deux matrices A, B n×n
sortie : matrice C n×n
1 n ← ligne[A]
2 Soit C une matrice n×n
3 pour i ← 1 à n faire
4 pour j ← 1 à n faire
5 cij ← 0
6 pour k ← 1 à n faire
7 cij ← cij + aik .bkj
8 fin pour
9 fin pour
10 fin pour

T(n)=c1+c2+n(n(c3+n(c4)))
= c1+c2+ n (nc3 +n2c4)
= c1+c2+ n²c3 +n3c4

11
3. Mesures de complexité

Soit A un algorithme, n un entier, Dn l’ensemble des entrées de taille n.


Posons : coût A(n) le nombre d’opérations fondamentales effectuées par A avec l’entrée n.

Complexité dans le meilleur des cas :


La complexité dans le meilleur des cas est obtenue par :
MinA(n)=min{coût A(n)/n ∈Dn}

Complexité dans le pire des cas :


La complexité dans le pire des cas est donnée par :
MaxA(n)=max{coût A(n)/n ∈Dn}

La complexité en moyenne :

MoyA( n)=Σn∈Dn p(n) . coût A(n) avec p(n) est une loi de probabilité sur les entrées.

NB : Généralement, on s’intéresse à la complexité dans le pire des cas.

Application :
entrée : tableau A[n]
sortie : tableau A trié par ordre croissant
1 Pour i ← 1 à n faire
2 pour j ← n jusqu’à i+1 faire
3 si A[j] < A[j-1] alors
4 permuter (A[j] ,A[j – 1])
5 fin si
6 fin pour
7 fin pour

Au pire des cas :


La complexité de tri à bulle est O(n²).
La notation O (Landau) est utilisée pour indiquer la borne supérieure asymptotique.

12
4. Classes de complexité

Les classes fréquentes de complexité sont :

Règles

Les quelques règles suivantes permettent de simplifier les complexités en omettant des termes
dominés :
● Les coefficients peuvent être omis : 3n2 devient n2.
● na domine nb si a > b : par exemple, n2 domine n.
● Une exponentielle domine un polynôme : ean domine na.
● Un polynôme domine un logarithme : n domine log n.
Théorème :

13
Exercice :
On considère l’algorithme suivant :
Entrée : un tableau de nombres T de taille n
Sortie : un nombre s
s=0
Pour i de 1 à n faire
s = s + T[i]
fin pour
retourner s

1. Que calcule l’algorithme ?


2. Montrer que la complexité de cet algorithme est linéaire.

5. Complexité d’un problème

La complexité des algorithmes a abouti à une classification des problèmes en fonction des
performances des meilleurs algorithmes connus qui les résolvent.
La complexité d’un problème A est la complexité du meilleur algorithme qui résout A.

Exercice :
On considère un tableau à une dimension contenant des lettres majuscules.
On désire compter la fréquence de chacune des 26 lettres de l’alphabet.
Ecrire deux procédures qui donnent en sortie un tableau de fréquence:
a. l’une où le tableau est parcouru 26 fois.
b. l’autre où le calcul est fait en un seul parcours.
c. Calculer la complexité du problème.
Solution :
a) La méthode qui parcourt le tableau 26 fois consiste à parcourir le texte pour compter
d’abord tous les A, puis compter tous les B, etc.
On utilise un tableau d’entiers de 26 cases, qui sert à mémoriser les occurrences.
char texte[TMAX] ;
int cpt, pos, occ[26] ;
for (cpt = 0 ;cpt< 26 ; cpt++) {
occ[cpt]= 0 ; //initialisation à zéro}

for(int i=1 ;i<=26 ;i++){


cpt = 0 ;
while (cpt<TMAX) {
if(texte[cpt]==’A’)
occ[1] ++ ;
cpt ++ ;}}
complexité O(n²)
14
b) La deuxième méthode demande de disposer de la conversion d’une lettre en un entier,
qui correspond à sa place dans l’alphabet.
char texte[TMAX] ;
int cpt, pos, occ[26] ;
for (cpt = 0 ;cpt< 26 ; cpt++) {
occ[cpt]= 0 ; //initialisation à zéro}

cpt = 0 ;
while (cpt<TMAX) {
pos = conversion(texte[cpt]) ;
occ[pos] ++ ;
cpt ++ ;}
complexité O(n)

6. Notations o (petit o), Ω (grand omega) et Θ (grand theta)

La notation o est utilisée pour indiquer que la borne supérieure n’est pas asymptotiquement
approchée.

Nous disons pour f ∈o(g) que f est un petit o de g et que f est négligeable devant g.

Exemples :
f(x) = 3x5 + x4 + x2

=0

f = o(x6) au voisinage de +

x6∈

en +∞ : (ln x) = o( )
en +∞ : = o(eax) lorsque a > 1

La notation Ω est utilisée pour indiquer la borne inferieure asymptotique.


Soit g une fonction définie sur une partie des nombres réels.

15
L’ensemble Ω(g) est défini ainsi :

Exemple :
5n²+1 ∈

Propriétés

1. g(n) ∈ O(f(n)) ⇔ f(n) ∈ Ω(g(n))


2. g(n) ∈ Θ(f(n)) ⇔ f(n) ∈ Θ(g(n))
3. Si c≥0, d>0, g(n) ∈ Θ(f(n)) et h(n) ∈ Θ(f(n)) alors c×g(n)+d×h(n) ∈ Θ(f(n))

Application :

Montrer que 5n + 3 log n + 10 n log n + 7n2 ∈ Θ(n2) ?

16
Solution :

 7n2 ∈ Θ(n2)
 10 n log n + 7n2 ∈ Θ(n2)
 3 log n + 10 n log n + 7n2 ∈ Θ(n2)
 5n ∈ Θ(n2)

Donc 5n + 3 log n + 10 n log n + 7n2 ∈ Θ(n2)

7. La relation ”Est équivalent à”

On dira que f et g sont équivalentes au voisinage du point a ssi :

On note ou ou encore

Exemples :

Au voisinage de 0 : ∼
Au voisinage de 0 : ∼

17

Vous aimerez peut-être aussi