IPEIGB AU : 2023/2024

CHAPITRE IV: Notion de Complexité et ses classes

1. Introduction
Il est important de pouvoir juger un programme un autre programme qui résout le même
problème. Il existe plusieurs critères sur lesquels on peut se baser pour pouvoir qualifier un
programme :
 Est-ce qu’il fait ce que nous lui demandons de faire ?
 Est-ce qu’il est muni d’une documentation qui décrit comment l’utiliser et comment il
fonctionne ?
 Est-ce que le code est facilement lisible ?
 Activité: Proposer en Python deux programmes différents pour vérifier la primalité d’un
entier n?
Afin de réaliser cette activité, on a besoin de mesurer le temps d’exécution de chaque
programme. En Python, nous pouvons simuler un chronomètre :
 on le déclenche juste avant le début du programme on l'arrête juste après la fin.
 le temps écoulé entre les deux pressions est la durée qui nous intéresse.
 Solution Activité:
Programme naïf : ce programme consiste à diviser n par tous les entiers qui lui sont
inférieurs. Si un de ces entiers est un diviseur de n, n n'est pas premier.
from time import *
def est_premier(n) : Résultat d’exécution:
a=time() >>> est_premier(2**31-1))
for i in range(2, n): 554.3090000152588 sec
if n% i == 0 : True
print(time()-a, "sec")
return (False)
print(time()-a, "sec")
return(True)

Programme rapide : Nos connaissances en arithmétique nous assurent que si nombre n'est
pas premier, un de ses diviseurs est inférieur à √ . La fonction est_premier devient alors :
from time import *
def est_premierRapide(n) : Résultat d’exécution:
a=time() >>> est_premierRapide(2**31-1)
for i in range(2,int(n**(1/2))+1): 0.009999990463256836 sec
if n% i == 0 : True
print(time()-a, "sec")
return (False)
print(time()-a, "sec")
return(True)
 Conclusion :
Dans l’étude de complexité d’un algorithme on ne mesure pas la durée en heures, minutes,
secondes, ...:
 cela impliquerait d'implémenter les algorithmes qu'on veut comparer ;
 de plus, ces mesures ne seraient pas pertinentes car le même algorithme sera plus
rapide sur une machine plus puissante.
L’étude de complexité consiste donc à utiliser des unités de temps abstraites
proportionnelles au nombre d'opérations effectuées.

Sections : MP1, PC1, T1& BG1 1

IPEIGB AU : 2023/2024

2. Définitions
 Complexité temporelle : c'est le nombre d'opérations élémentaires effectuées par une
machine qui exécute le programme et le temps nécessaire pour chaque opération.
 Complexité spatiale : c'est le nombre de positions mémoire utilisées par une machine
qui exécute le programme.

2.1. Types de complexité temporelle

La complexité temporelle de l’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. On a trois types :
 La complexité au pire: temps d'exécution maximum, dans le cas le plus défavorable.
 La complexité au mieux: temps d'exécution minimum, dans le cas le plus favorable.
 La complexité moyenne: temps d'exécution dans un cas médian, ou moyenne.
Notations:
 Dn : l’ensemble des données de taille n
 T(n) : le nombre d’opérations sur un jeu de données de taille n
2.2. Calcul du coût d’un programme
Calculer le coût d’un programme revient à calculer le nombre d’opérations effectuées en
fonction de la taille des données. on se fonde en général sur le modèle de complexité suivant :
 Une affectation, une comparaison ou l’évaluation d’une expression arithmétique (+,-
,/ ,*,//,%,**) ayant un faible temps d’exécution considéré comme l’unité de mesure.
 Le coût des instructions p et q en séquence est la somme des coûts de l’instruction p
et de l’instruction q.
 Le coût d’un test if
if b: p
else: q
Le coût d’un test est égal au maximum des coûts des instructions p et q, plus le temps
d’évaluation de l’expression b.
 Le coût d’une boucle for
for i in range(n):
p
Le coût d’une boucle for est égal au nombre de répétitions multiplié par le coût du
bloc d’instructions p.
 Le cas d’une boucle while
while condition:
p
Le cas d’une boucle while est plus complexe à traiter puisque le nombre de répétitions
n’est en général pas connu a priori. On peut majorer le coût de l’exécution de la boucle
par le nombre de répétitions effectuées.
Exemple: Calculer la factorielle d’un entier n

Le coût de l’algorithme = Nombre total d’opérations

= 1 Affectation + (n-1) *( 1 affectation + 1 multiplication)+1 renvoi
T( n) = 1+ (n-1)*2+1 = 2* n

Sections : MP1, PC1, T1& BG1 2

IPEIGB AU : 2023/2024

3. Notion de Landau O
Il faut noter que dans le calcul de la complexité d’un algorithme ce qui est important c’est
l’ordre de grandeur du nombre d’opérations fondamentales. Soit T(n) est le nombre
d’opérations effectuées. On dit que T(n) est en O(f(n)) s’il existe deux constantes positives c
et n0 telles que T(n)≤c × f(n) pour tout n>n0. Où f est d'habitude une combinaison de
polynômes, logarithmes ou exponentielles.

( ) ( ( )) ( ) ( )

Les règles de la notation O :

 Les termes constants : ( ) ( )
 Les constantes multiplicatives sont omises : ( ) ( ) ( )
 L'addition en prenant le maximum : ( ) ( ) ( ) ( ( ) ( ))
 La multiplication reste inchangée : ( ) ( ) ( )

Exemple : Supposant que le temps d'exécution d’un algorithme est décrit par la fonction
T(n) = 3n2+10n+10, Calculer O(T(n))?
O(T(n)) = O(3 n2 + 10n + 10) = O(max (3 n2, 10n, 10)) = O(3 n2) = O (n2)
3.1. Classes de complexité
Classe Notation O Exemple
Constante O(1) Accéder au premier élément d'un ensemble de données
Linéaire O(n) Parcourir un ensemble de données
Logarithmique O(log(n)) Couper un ensemble de données en deux parties égales, puis couper ces
moitiés en deux parties égales, etc.
Quasi-linéaire O(n log(n)) Couper répétitivement un ensemble de données en deux et combiner les
solutions partielles pour calculer la solution générale
Quadratique O(n2) Parcourir un ensemble de données en utilisant deux boucles imbriquées
P
Polynomiale O(n ) Parcourir un ensemble de données en utilisant P boucles imbriquées
n
Exponentielle O(a ) Générer tous les sous ensembles possibles d'un ensemble de données

3.2. Calcul de la complexité temporelle

o Cas d'une instruction simple (écriture, lecture, affectation) : Le temps d'exécution
de chaque instruction simple est O(1).
o Cas d'une suite d'instructions simples: Le temps d’exécution d'une séquence
d'instruction est déterminé par la règle de la somme. C'est donc le temps de la séquence
qui a le plus grand temps d’exécution:
( ) ( ) ( ( ) ( ).
Traitemen1 T1(n)
Traitemen2 T2(n) T(n) = T1(n) + T2(n)
o Cas d'un traitement conditionnel : Le temps d'exécution d'une instruction if 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.
if<condition> :
Traitement1
else: O(Tcondition) + max(O(TTraitement1) , O(TTraitement2))
Traitement2
o 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.

Sections : MP1, PC1, T1& BG1 3

IPEIGB AU : 2023/2024

Boucle for Boule while

for i in range(indDeb,indFin+1): while<condition> :
Traitement Traitement
Supposant que m est le nombre d’itérations
∑ ( )
( ( ) ( ))
( ( ) ) ( ( ) ( )

Pour calculer la complexité d'un programme :

1. on calcule la complexité de chaque partie du programme;
2. on combine ces complexités conformément aux règles qu'on vient de voir ;
3. on simplifie le résultat grâce aux règles de simplifications suivantes:
 on remplace les constantes multiplicatives par 1,
 on annule les constantes additives,
 on conserve le terme dominant.
Exemple: T(n)=5n3-6n2+4
 On remplace les constantes multiplicatives par 1 : 1n3-1n2+4
 On annule les constantes additives : 1n3-1n2
 On conserve le terme dominant : n3-n2
 Solution : T(n)=O(n3)

Exercice : Calcul de la complexité de la fonction factorielle

La complexité de la fonction : O(1)+O(n)*O(1)+O(1) = O(n)

Des cas de complexité fréquemment utilisés:

Sections : MP1, PC1, T1& BG1 4

IPEIGB AU : 2023/2024

Travaux dirigés :

Notion de Complexité et ses classes

Exercice 1 :
Calculer la complexité des programmes:
 est_premier et est_ premierRapide

Exercice 2 :
Quel est le coût de la fonction variance en fonction de la longueur de la liste L en déduisant sa
complexité ? N’y a-t-il pas moyen de faire plus rapide ?

def moyenne (L) :

s = 0.0
for x in L :
s += x
return s / len (L)
def variance (L) :
s = 0.0
for x in L :
t = x - moyenne (L)
s += t * t
return s / len (L)

L = [0 ,1 ,2 ,2 ,3 ,1 ,3 ,0]
print moyenne (L)
print variance (L)

Exercice 3 :
1) Montrez que la complexité de la fonction suivante est quadratique en n.

2) Que fait cette fonction ?

3) Donnez une version linéaire de cet algorithme.

Sections : MP1, PC1, T1& BG1 5