Université Kasdi-Merbah Ouargla - Faculté des Nouvelles Technologies de L’information et de la

Communication - Département d’Informatique et Technologies de l’Information.

Chapitre 2 : Complexité des algorithmes

1- Introduction
Ce que l’on entend par complexité des algorithmes est une évaluation du coût d’exécution d’un
algorithme en termes de temps (complexité temporelle) ou d’espace (complexité spatiale).
Pour rendre en compte la complexité des calculs lors de l’exécution d’un programme, il faut tenir
compte de ces facteurs suivants :
• La vitesse de l’ordinateur
• L’ingéniosité du langage d’implémentation
• La dépendance des entrées du programme
Nous ferons ici abstraction de ces facteurs, pour nous concentrer sur le coût des actions résultant
de l’exécution de l’algorithme, en fonction d’une taille n des données traitées. Ceci permet en
particulier de comparer deux algorithmes traitant le même calcul. Nous verrons également que
nous sommes intéressés par un comportement asymptotique ( que se passe -t’il quand n tend vers
l’infini ?) que par un calcul exact pour n fixé.

2- Efficacité en temps et en espace

L’efficacité se mesure sur deux dimensions :
• L’espace en mémoire
• Le temps d’exécution
Le plus souvent, on ne peut avoir qu’une de ces deux dimensions, c'est-à-dire avoir un programme
qui ne prend pas assez d’espace en mémoire mais qui est moins rapide, ou un programme qui est très
rapide mais qui prend assez d’espace en mémoire.

Exemple

/*Permute les contenus de deux variables*/ /* Permute les contenus de deux variables*/
Var x, y, z: entier entier x, y
z←x x ← y-x
x ←y y ← y-x
y ←z x ← y+x

• la première méthode utilise une variable supplémentaire et réalise 3 affectations.

• la deuxième méthode n'utilise que les deux variables dont on veut échanger les valeurs, mais
réalise 3 affectations et 3 opérations. Ces deux concepts sont appelés la: complexité en temps
et en espace de l’algorithme
Nous allons nous intéresser dans ce cours qu’à l’aspect temps car la mémoire ce n’est pas ce qui
manque aux ordinateurs de nos jours.
▪ La complexité (temporelle) d’un algorithme est la mesure du nombre d’opérations
fondamentales (affectations, comparaisons, opérations arithmétiques) 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 traitées.
Ceci permet en particulier de comparer deux algorithmes traitant le même calcul.

L’enseignante Marref . N Module ASD - Licence 2ème Année Page 1

 Université Kasdi-Merbah Ouargla - Faculté des Nouvelles Technologies de L’information et de la
Communication - Département d’Informatique et Technologies de l’Information.

▪ En d’autres termes, il permet de déterminer si un algorithme A est meilleur qu’un algorithme

B indépendamment de la machine, du langage de programmation, du compilateur et des détails
d’implémentation.
3- Type de la Complexité
Pour essayer d’estimer le temps que prend un programme pour s’exécuter on peut se servir du :
• Meilleur cas : C’est le plus petit nombre d’opérations qu’aura à exécuter l’algorithme sur un
jeu de données de taille fixe, ici n .
𝑇𝑚𝑖𝑛 (𝑛) = 𝑚𝑖𝑛𝑑∈𝐷𝑛 𝑇(𝑑)
• Pire des cas : C’est le plus grand nombre d’opérations qu’aura à exécuter l’algorithme sur un
jeu de donnée de taille fixée, ici n.
𝑇𝑚𝑎𝑥 (𝑛) = 𝑚𝑎𝑥𝑑∈𝐷𝑛 𝑇(𝑑)
• Cas moyen : C’est la moyenne des complexités de l’algorithme sur des jeux de données de
taille n .
𝑇(𝑑)
𝑇𝑚𝑜𝑦 (𝑛) = ∑ ⁄|𝐷 |
𝑛
𝑑∈𝑛

Notations:
𝑫𝒏 l’ensemble des données de taille n
T(n) le nombre d’opérations sur un jeu de données de taille n
Par exemple , pour la recherche séquentielle d’un élément x dans un tableau :

14 3 2 17 25 0 26 30 8 4

• Le meilleur cas , est que l’on trouve l’élément à la première comparaison. ( exp x = 14 )
• Le pire des cas est que l’on parcoure tous les éléments du tableau , et que l’élément recherché
se trouve le dernier ou ne s’y trouve pas. ( exp x = 4 ou x = 6 )
• Le cas moyen est que l’élément recherché se trouve à la 4éme , 5éme position par exemple.
Nous nous intéressons particulièrement au Pire des cas car c’est celui qui arrive le plus souvent. Les
deux autres cas ne posent vraiment pas grand problème.
4- Les notations O et Θ
Définition 1
Soient 𝑓 et 𝑔 deux fonction de N dans ℜ+∗ , s’il existe un réel c > 0 et un entier positif ( un rang
) 𝑛0 tel que
∀ 𝑛 > 𝑛0 , 𝑓(𝑛) ≤ 𝑐 × 𝑔(𝑛)

On dit que 𝒇 est en 𝑶 (𝒈) (𝑓 est asymptotiquement dominée par 𝑔

Exemple1 𝑓(𝑛) = 3𝑛 + 1 , 𝑔(𝑛) = 𝑛
3𝑛 + 1 𝑒𝑠𝑡 𝑒𝑛 𝑂(𝑛) , en effet pour 𝒏𝟎 = 𝟏 𝒆𝒕 𝒄 = 𝟒 on a bien ∀ 𝑛 > 𝑛0 3𝑛 + 1 ≤ 4𝑛
Définition 2
Soient 𝑓 et 𝑔 deux fonction de N dans ℜ+∗ ,
Si 𝑓 est en 𝑂 (𝑔) et 𝑔 est en 𝑂 (𝑓) alors , on dit que 𝑓 𝑒𝑠𝑡 𝑒𝑛 Θ(g)
( 𝑓 𝑒𝑡 𝑔 sont de même ordre de grandeur asymptotique )

L’enseignante Marref . N Module ASD - Licence 2ème Année Page 2

 Université Kasdi-Merbah Ouargla - Faculté des Nouvelles Technologies de L’information et de la
Communication - Département d’Informatique et Technologies de l’Information.

Exemple2 : 𝑓(𝑛) = 3𝑛 + 1 , 𝑔(𝑛) = 𝑛

3𝑛 + 1 𝑒𝑠𝑡 𝑒𝑛 𝛩(𝑛) , en effet d’une part , 3𝑛 + 1 𝑒𝑠𝑡 𝑒𝑛 𝑂(𝑛) , d’autre part pour 𝒏𝟎 = 𝟐 𝒆𝒕 𝒄 =
𝟐 , on a bien ∀ 𝑛 > 𝑛0 𝑛 ≤ 2(3𝑛 + 1) , et donc 𝑛 𝑒𝑠𝑡 𝑒𝑛 𝑂(3𝑛 + 1)
Remarque : En pratique 𝑓 représente une quantité à étudier ( temps , nombre d’opération ) et 𝑔 fait
partie d’une échelle de fonctions simples ( 𝑛 , 𝒍𝒐𝒈𝟐 (𝒏), 𝒏𝒍𝒐𝒈𝟐 (𝒏), 𝒏𝟐 , … ) destinée à informer sur le
comportement asymptotique de 𝑓
Propriété 1
𝑓 𝑒𝑠𝑡 𝑒𝑛 𝛩(𝑔) si et seulement si : il existe c , d réels > 0 , et un rang 𝒏𝟎 tel que , ∀ 𝒏 > 𝒏𝟎
On a 𝒅. 𝒈(𝒏) ≤ 𝒇(𝒏) ≤ 𝒄. 𝒈(𝒏)
La notation 𝜣 se ramène donc à un encadrement ( à partir d’un certain rang ) de la quantité 𝑓 étudiée.
Propriété 2
1) f est en (g) si:
f(n)
Lim
n→∞
⁄g(n) = 𝒂 ≠ 𝟎
2) f est en O(g) mais f n'est pas en (g) si:

f(n)
Lim
n→∞
⁄g(n) = 𝟎
3) f n'est pas en O(g) si:
f(n)
Lim
n→∞
⁄g(n) = ∞

Exemple3
𝑓(𝑛) = 3𝑛 + 1 , 𝑔(𝑛) = 𝑛
Lim
n→∞
𝟑𝒏 + 𝟏⁄
𝒏 = 𝟑 ≠ 𝟎 , donc 3𝑛 + 1 𝑒𝑠𝑡 𝑒𝑛 (n)

Les règles de la notation O sont les suivantes :

• Les termes constants : O(c) = O(1)
• Les constantes multiplicatives sont omises : O(cT ) = cO(T) = O(T)
• L'addition est réalisée en prenant le maximum : O(T1) + O(T2) = O(T1 + T2) =
max(O(T1);O(T2))
• La multiplication reste inchangée mais est parfois réécrite d'une façon plus compacte
O(T1)O(T2) = O(T1T2)
Exemple : Supposant que le temps d'exécution d’un algorithme est décrit par la fonction
𝑇(𝑛) = 3𝑛2 + 10𝑛 + 10 Calculer O(T(n))?
O(T(n)) = O(3𝑛2 + 10𝑛 + 10) ) =
O(max (3𝑛2 , 10n, 10)) =
O(3𝑛2 ) = O (𝑛2 )
Remarque: Pour n = 10 nous avons :
• Temps d'exécution de 3𝑛2 : 3(102 ) / (3(102 )+10(10)+10 )= 73,2%
• Temps d'exécution de 10n : 10(10) / (3(10)2+10(10)+10 )= 24,4%

L’enseignante Marref . N Module ASD - Licence 2ème Année Page 3

 Université Kasdi-Merbah Ouargla - Faculté des Nouvelles Technologies de L’information et de la
Communication - Département d’Informatique et Technologies de l’Information.

• Temps d'exécution de 10 : 10 / (3(10)2+10(10)+10) = 2,4% Le poids de 3𝑛2 devient encore

plus grand quand n = 100, soit 96,7% On peut négliger les quantités 10n et 10. Ceci explique
les règles de la notation O

5- Classes de complexité

L’enseignante Marref . N Module ASD - Licence 2ème Année Page 4

 Université Kasdi-Merbah Ouargla - Faculté des Nouvelles Technologies de L’information et de la
Communication - Département d’Informatique et Technologies de l’Information.

6- Règles de Calcul de Complexité d’un algorithme itératif

Déterminer la complexité d’un algorithme A revient à trouver un ordre de grandeur pour la fonction
𝑇𝐴 (𝑛) représentant le temps d’exécution de cet algorithme en fonction de la taille n des données
d’entrée et les opérations fondamentales.
1- Cas d'une instruction simple : écriture, lecture, affectation
Le temps d'exécution de chaque instruction simple est O(1).
2- Cas d’une séquence d’instructions : On considère la complexité maximale.

La complexité est
O(T(n)) = max ( O( 𝑇1 (𝑛)), 𝑂(𝑇2 (𝑛)))

Exemple :

La complexité de cette séquence vaut max(O(1),O(1))=O( 1).

3- Cas d’un traitement conditionnel : Le temps d'exécution d'une instruction SI est le temps
d’exécution des instructions exécutées sous condition, plus le temps pour évaluer la condition.
Pour une alternative, on se place dans le cas le plus défavorable.

Si ( condition) alors
Traitement 1
Sinon
Traitement2
Fsi
/* O(T(condition))+max(O(traitement1),O(traitement2)) */

L’enseignante Marref . N Module ASD - Licence 2ème Année Page 5

 Université Kasdi-Merbah Ouargla - Faculté des Nouvelles Technologies de L’information et de la
Communication - Département d’Informatique et Technologies de l’Information.

4- Cas d’un traitement itératif : Le temps d’exécution d'une boucle est la somme du temps pour
évaluer le corps et du temps pour évaluer la condition. Souvent ce temps est le produit du
nombre d'itérations de la boucle par le plus grand temps possible pour une exécution du corps.
• boucle tant que

• boucle Pour

5- Cas de fonctions ou procédures non récursives : On évalue d'abord les fonctions et

procédures qui ne contiennent pas d’appels à d’autres fonctions et procédures, puis celles qui
contiennent des appels aux précédentes, etc....

Remarque : Pour les fonctions et procédures récursives , l’analyse donne en général lieu à la
résolution de relations de récurrences.

Exemple1

// calcul de 1+2+3+…..+n Nombre de fois Ordre de grandeur

Static int somme ( int n ) {
1 Int i = 1 ; 1 O(1)
2 Int s = 0; 1 O(1)
3 While ( I <= n ) { n +1 (n + 1)O(1)
4 s= s+ i ; n n O(1)
5 i ++ ; n n O(1)
}
6 Return s ; 1 O(1)

T( n) = 1+1+n+1+n+n+1 = 3n+4 ( représente le nombre d’opérations )

O(T(n))= O(3n+4)= max(O(3n),O(4))=O(3n)= O(n)

Ou bien O(T(n)) = O(1+1+∑𝑛𝑖=1 3 + 1+1)=O(3n+4) = O(n)

L’enseignante Marref . N Module ASD - Licence 2ème Année Page 6

 Université Kasdi-Merbah Ouargla - Faculté des Nouvelles Technologies de L’information et de la
Communication - Département d’Informatique et Technologies de l’Information.

Exemple2

// tri par selection

static void tri_selection ( int [] t , int n) {
int pos_min , min ;
1 for ( int i = 0 ; i< n-1 ; ++i ) {
2 pos_min = i ;
3 min = t[i] ;
4 for ( int j=i+1 ; j < n ; ++j) {
5 if ( t[j] < min ) {
6 pos_min=j;
7 min = t[j];
}
}
8 t[pos_min] = t[i];
9 t[i] = min ;
}
}

• L’action 1 est exécutée n fois

• Les actions 2 , 3 , 8 , 9 ( chacune des actions a une complexité O(1) , sont exécutées n-1
fois , une fois sur chaque itération de la boucle externe )
• A la première itération ( i = 0 )
- L’action 4 est exécutée n fois
- L’action 5 et exécutée n-1 fois
- Et en supposant le plus mauvais cas où les éléments sont dans un ordre
descendant , les actions 6 et 7 ( chacune en O(1) sont exécutées ( n-1 ) fois

• A la deuxième itération ( i = 1 )
- L’action 4 est exécutée n-1 fois
- Et les actions 5 , 6 , et 7 sont exécutées n-2 fois

Etc ….

Donc l’action 4 est exécutée (n ) + ( n-1 ) + (n-2) +……………+2

𝑛(𝑛+1)
Or on sait que 1 + 2 + 3 + ⋯ … + 𝑛 =
2

𝑛(𝑛+1)
Donc l’action 4 est exécutée : −1
2

Les actions 5 , 6 et 7 sont exécutées (n-1) + (n-2) + ……..+2+1

L’enseignante Marref . N Module ASD - Licence 2ème Année Page 7

 Université Kasdi-Merbah Ouargla - Faculté des Nouvelles Technologies de L’information et de la
Communication - Département d’Informatique et Technologies de l’Information.

𝑛(𝑛−1)
Sont exécutées
2

Donc le nombre d’opérations total est :

𝑛(𝑛+1) 𝑛(𝑛−1)
T(n) = 𝑛 + 4(𝑛 − 1) + −1+3( )
2 2

𝑛2 +𝑛 3𝑛2 −3𝑛
T(n) = 𝑛 + 4𝑛 − 4 − 1 + +
2 2

T(n) = 5𝑛 − 5 + 2𝑛2 − 𝑛

T(n ) = 2𝑛2 + 4𝑛 − 5

Donc la complexité est = O( T(n)) = O(𝑛2 )

Autre méthode :
𝒏−𝟏 𝒏−𝟐 𝒏 𝒏−𝟏 𝒏−𝟐

𝑻(𝒏) = ∑ 𝟏 + ∑(𝟐 + 𝟐 + ∑ 𝟏 + ∑ 𝟑) = 𝒏 + ∑(𝟒 + (𝒏 − 𝒊 − 𝟏 + 𝟏) + 𝟑(𝒏 − 𝟏 − 𝒊 − 𝟏 + 𝟏))

𝒊=𝟎 𝒊=𝟎 𝒋=𝒊+𝟏 𝒋=𝒊+𝟏 𝒊=𝟎

𝒏−𝟐 𝒏−𝟐 𝒏−𝟐

= 𝒏 + 𝟒 ∑ 𝟏 + ∑(𝒏 − 𝒊 ) + 𝟑 ∑(𝒏 − 𝟏 − 𝒊 )
𝒊=𝟎 𝒊=𝟎 𝒊=𝟎

= 𝒏 + 𝟒(𝒏 − 𝟏) + (𝒏 + 𝒏 − 𝟏 + 𝒏 − 𝟐 + ⋯ … + 𝒏 − (𝒏 − 𝟐)) + 𝟑(𝒏 − 𝟏 + 𝒏 − 𝟐 + ⋯ … . +𝒏 − 𝟏 − (𝒏 − 𝟐))

𝒏(𝒏 + 𝟏) 𝒏(𝒏 − 𝟏)
= 𝒏 + 𝟒𝒏 − 𝟒 + − 𝟏 +𝟑
𝟐 𝟐

𝒏𝟐 + 𝒏 + 𝟑𝒏𝟐 − 𝟑𝒏
= 𝟓𝒏 − 𝟓 +
𝟐

𝟒𝒏𝟐 − 𝟐𝒏
𝟓𝒏 − 𝟓 + = 𝟓𝒏 − 𝟓 + 𝟐𝒏𝟐 − 𝒏
𝟐

T(n ) = 𝟐𝒏𝟐 + 𝟒𝒏 − 𝟓

Donc O(T(n) )= O(𝟐𝒏𝟐 + 𝟒𝒏 − 𝟓) = 𝑶(𝒏𝟐 )

L’enseignante Marref . N Module ASD - Licence 2ème Année Page 8

 Université Kasdi-Merbah Ouargla - Faculté des Nouvelles Technologies de L’information et de la
Communication - Département d’Informatique et Technologies de l’Information.

Exemple 3

for(i=1;i<=N;i++){
Res=X+Y+Z+Res;
if(T[i]+K < B)
// Action1
for(j =1;j<= N;j++)
Res = Res +T[j];
else
// Action2
Res=Res+T[i];
}

• Opc(i,n) le nombre d’additions dans la structure « if........else... » à la ième itération de la

boucle externe,
• Op1(i,n) le nombre d’additions dans Action1 et
• Op2(i,n) le nombre d’additions dans Action2 :
Op(n) = ∑𝑛𝑖=1 3 + 𝑂𝑝𝑐(𝑖, 𝑛)
Opc(i, n) =1 + Max(Op1(i, n),Op2(i, n)) =1+ Max(n,1) = 1+ n
Op(n) = ∑ni=1 4+n = n2 + n

O( Op(n)) = O( n2 + n) = O( n2 )

L’enseignante Marref . N Module ASD - Licence 2ème Année Page 9