01 - Notion de Complexité Algorithmique

Notion de complexité algorithmique.
2ADS Advanced Algorithms
©
© SUPINFO
SUPINFO International
International University
University –– http://www.supinfo.com
http://www.supinfo.com
Objectifs de ce module
• Introduire la notion de complexité afin de
comparer les performances de différents
algorithmes.
• Présenter les principales classes de complexité.
• Effectuer des premiers calculs de complexité.
©
© SUPINFO
Plan de ce module
1. Généralités sur la complexité.

2. Premiers calculs de complexité.
3. Comportement asymptotique des fonctions.
©
© SUPINFO
1. GENERALITES SUR LA
COMPLEXITE.
©
© SUPINFO
Plan de ce chapitre
a. But d’un calcul de complexité.

b. Les deux types de complexité.
c. De quoi est fonction la complexité ?
d. Quelques calculs de sommes usuelles.
e. Rappels sur la fonction logarithme.
©
© SUPINFO

But :
•Comparer l’efficacité d’algorithmes résolvant le même

problème.
•Établir lequel de ces algorithmes est donc le plus optimal.
©
© SUPINFO

Contraintes sur les règles de comparaison
Elles doivent être indépendantes :
•Du langage de programmation.

•Du processeur.
•Du compilateur.
©
© SUPINFO

Remarque :
• Le premier réflexe qui consisterait à « coder » les

algorithmes sur un ordinateur puis à comparer les vitesses
d’exécution n’est donc pas le bon.
• Il ne vérifie en effet pas les contraintes précédentes.
©
© SUPINFO

Comment faire ?
• On va effectuer des calculs sur l’algorithme en lui même,

dans sa version « papier ».
• Les résultats de ces calculs fourniront une estimation du

temps d’exécution de l’algorithme, et de la taille mémoire
occupée lors de son fonctionnement.
©
© SUPINFO

Note historique :
• Le premier à avoir systématisé le fait de calculer la

complexité d’un algorithme est Donald Knuth dans sa série
d’ouvrage « the art of computer programming ».
©
© SUPINFO

Complexité en temps :
•Décompte du nombre d’opérations élémentaires

(affectation, calcul, comparaison…) effectuées par
l’algorithme.
•Hypothèse de base : toutes les opérations élémentaires sont

à égalité de coût.
©
© SUPINFO

Complexité en temps (suite) :
•Le temps d’exécution sera ainsi proportionnel au nombre

d’opérations élémentaires.
•Ce décompte est donc une “bonne” définition de la

complexité en temps.
©
© SUPINFO

Complexité en espace :
• Taille nécessaire pour stocker les différentes structures de

données.
• On s’intéressera peu à cette question dans la suite du

cours.
©
© SUPINFO

En fonction de quoi va t-on calculer la complexité d’un
algorithme ?
• En fonction de la taille des données passées en

paramètres.
• Par exemple pour un algorithme de tri, ce sera le nombre

de valeurs à trier.
©
© SUPINFO

Hypothèse : on considèrera que nos algorithmes n’ont
qu’une donnée. La taille de cette donnée sera
nécessairement un entier naturel.
La complexité en temps d’un algorithme sera donc une

fonction de IN dans IR.
Notation :
T : IN ® IR
n  T ( n)
©
© SUPINFO

Remarque importante :
•Souvent la complexité dépendra de la donnée en elle même

et pas seulement de sa taille.
©
© SUPINFO

Exemple : recherche séquentielle d’un élément dans une liste
non triée.
•On parcourt un par un les éléments jusqu’à trouver le “bon”.
•Ce parcours peut s’arrêter dès le début si le premier

élément est celui cherché.
•Mais on peut également être amené à parcourir le tableau

en entier si l’élément cherché est en dernière position.
©
© SUPINFO

Différents types de complexité en temps :
• Complexité « dans le meilleur des cas ».
• Complexité « dans le pire des cas ».
• Complexité « en moyenne ».
On calculera le plus souvent la complexité « dans le pire des

cas ».
©
© SUPINFO

Autre remarque importante :
•Si la donnée en elle même est un nombre entier, la façon de

le représenter influera beaucoup sur l’appréciation de la
complexité.
•Par exemple si n = 4096 on peut considérer que la taille de n

est :
– 4096 (façon naturelle de voir les choses).
– 13 (car son écriture en binaire comporte 13 chiffres).
– 4 (car son écriture en décimal comporte 4 chiffres).
©
© SUPINFO
d. Quelques calculs de sommes usuelles

Somme d’une constante c :
å c =n ´ c
k=1
©
© SUPINFO

Somme des n premiers entiers :
n
n ´ ( n +1)
å k= 2
k=1
©
© SUPINFO

Une preuve “sans mots” du résultat précédent :
©
© SUPINFO

Somme des n premiers carrés d’entiers :
n
n ´ ( n +1) ´ ( 2n +1)
åk = 2
6
k=1
©
© SUPINFO

Somme des n premiers termes d’une suite géométrique :
n n+1
1- q
Si q ¹ 1, å q k =
k=0 1- q
©
© SUPINFO

Logarithme de base a : soit a > 0, a != 1. Il s’agit de l’unique
fonction vérifiant
" x, y > 0, log a ( xy) =log a ( x ) + log a ( y)

log a ( a) =1
©
© SUPINFO

Fonctions logarithmes usuelles :
•Si a = e, il s’agit du logarithme népérien, noté ln.
•Si a = 2, il s’agit du logarithme binaire.
•Si a = 10, il s’agit du logarithme décimal.
©
© SUPINFO

Règles opératoires : soit a > 0, a != 1.
æx ö
" x, y > 0, log a ç ÷=log a ( x ) - log a ( y )
èy ø
" x > 0, " n Î IN, log a ( x n ) =n. log a ( x )
log a ( 1) =0
©
© SUPINFO

Relation de proportionnalité entre les fonctions logarithmes
: soient a > 0, a != 1, b > 0, b != 1.
log b ( x )
" x > 0, log a ( x ) =
log b ( a)
©
© SUPINFO

Fonction réciproque : soit a > 0, a != 1.
log a ( x )
" x > 0, a =x
" x Î IR, log a ( a x ) =x
©
© SUPINFO

Exemple : le logarithme binaire et sa fonction réciproque.
©
© SUPINFO
Fin de ce chapitre
Avez – vous des questions ?
©
© SUPINFO
2. PREMIERS CALCULS DE
COMPLEXITE.
©
© SUPINFO
Plan de ce chapitre
a. Algorithmes sans ruptures de séquences.

b. Le cas des structures conditionnelles.
c. Le cas des structures itératives.
d. Premiers exemples un peu plus élaborés.
e. Remarques sur la précision à apporter.
©
© SUPINFO
a. Algorithmes sans ruptures de seq.

Rappel de l’hypothèse de base :
• Toutes les opérations élémentaires (affectation, calcul,

comparaison…) sont à égalité de coût.
• Le temps d’exécution est donc proportionnel au nombre

de ces opérations.
©
© SUPINFO

Principe général :
•Il suffit juste de dénombrer le nombre d’opérations

successives de l’algorithme.
©
© SUPINFO

Exemple : conversion d’un nombre de secondes en heures,
minutes, secondes.
def conversion(n):
h = n // 3600
m = (n - 3600*h) // 60
s = n % 60
return h,m,s
©
© SUPINFO

Exemple (suite) :
•On a cinq opérations arithmétiques et trois affectations.
•On a donc :
T ( n ) =8
©
© SUPINFO
b. Le cas des structures conditionnelles

•Il faut dénombrer le nombre de conditions du test.
•On décompte ensuite le nombre d’opérations élémentaires

de chacune des alternatives.
•On prend enfin le maximum du décompte précédent pour

obtenir la complexité dans le pire des cas.
©
© SUPINFO

Exemple : calcul de -1 à la puissance n.
def puissanceMoinsUn(n):
if n%2==0:
res = 1
else:
res = -1
return res
©
© SUPINFO

Exemple (suite) :
•On a une opération arithmétique, une comparaison et une

affectation.
•On a donc :
T ( n ) =3
©
© SUPINFO
c. Le cas des structures itératives

Si chaque itération a le même nombre d’opérations :
– On décompte le nombre d’itérations.

– Il faut ensuite dénombrer le nombre de tests pour “rester
dans la boucle” et le nombre d’opérations élémentaires de
chaque itération.
– On conclut en multipliant les deux résultats précédents
©
© SUPINFO

Principe général (suite) :
Si chaque itération n’a pas le même nombre d’opérations :
– On doit alors additionner le nombre d’opérations de chaque

itération.
©
© SUPINFO

Exemple : calcul itératif de la somme des n premiers entiers.
def sommeEntiers(n):
somme = 0
for i in range(n+1):
somme += i
return somme
©
© SUPINFO

Exemple (suite) :
•Ici chaque itération a le même nombre d’opérations. On a

deux affections (i et somme), deux additions (i et somme) et
une conditionnelle (i).
•On a donc :

( )
T n =5n +1
©
© SUPINFO

Exemple (suite) : calcul de cette même somme en utilisant
une formule explicite (voir sous-partie 1.d).
def sommeEntiersBis(n):
return n*(n+1)//2
©
© SUPINFO

Exemple (suite et fin) :
•On a trois opérations arithmétiques donc T ( n ) =3
•Il s‘agit d’un premier exemple où l’on peut comparer

l’efficacité de deux algorithmes répondant à la même
question.
•La conclusion est bien sûr ici évidente.
©
© SUPINFO
d. Premiers exemples plus élaborés.

Recherche itérative d’un élément dans une liste : si
l’élément est trouvé la fonction retourne sa position sinon
elle retourne -1.
def recherche(l,x):
for i in range(len(l)):
if l[i]==x:
return i
return -1
©
© SUPINFO

Complexité de l’algorithme itératif de recherche :
•Ici la complexité sera fonction de la longueur de la liste.

Notons n cette longueur.
•Dans le pire des cas il faut parcourir toute la liste pour

trouver (ou non) l’élément.
©
© SUPINFO

Complexité de l’algorithme itératif de recherche (suite) :
•À chaque itération, on a le même nombre d’opérations : une

affectation, une addition et deux comparaisons.
•Cela donne donc :

( )
T n =4n
©
© SUPINFO

Tri par sélection d’une liste de nombres :
def triSelection(l):
for i in range(len(l)-1):
ind_mini=i
for j in range(i+1,len(l)):
if l[j]<l[ind_mini]:
ind_mini=j
l[i],l[ind_mini]=l[ind_mini],l[i]
return l
©
© SUPINFO

Complexité de l’algorithme de tri par sélection :
•Ici aussi la complexité sera fonction de la longueur de la

liste. Notons n cette longueur.
•Le pire des cas correspond à une liste triée par ordre
décroissante.
©
© SUPINFO

Complexité de l’algorithme de tri par sélection (suite) :
•À chaque itération de la boucle principale on n’a pas le

même nombre d’opérations :
– On a toujours les 6 mêmes opérations (à propos de i,

ind_mini et l’échange).
– On a les opérations dues à la boucle la plus “interne”.
©
© SUPINFO

•Cette boucle “interne” a elle par contre le même nombre

d’opérations par itération : 5.
•A la première itération de la boucle “externe” la boucle

“interne” fera n-1 itérations.
•Puis à la seconde elle fera n-2 itérations. Etc.
©
© SUPINFO

n- 1
( )
6 +5´ n - 1 +6 +5´ n - 2 +... +6 +5´ 1 = ( ) å ( 6 +5´ i )
i=1
n- 1
= ( )
6 ´ n - 1 +5´ åi
i=1
= 6 ´ ( n - 1) +5´
( n - 1) ´ n
2
5 2 7
= n + n- 6
2 2
©
© SUPINFO

Complexité de l’algorithme de tri par sélection (fin) :
•Conclusion, la complexité dans le pire des cas du tri par

sélection est
5 2 7
T  n  n  n  6
2 2
©
© SUPINFO
e. Remarques sur la précision

• À la vue des calculs précédents, on comprend bien que
donner un résultat “précis” va vite devenir impossible et
inutile.
• Impossible : comment ne pas oublier une opération

élémentaire dans un algorithme de quelques centaines de
lignes ?
• Inutile : que la complexité soit égale à 4n + 2 ou 3n + 5,

cela ne change pas la “qualité” de l’algorithme.
©
© SUPINFO
e. Remarques sur la précision

• On va donc s’intéresser en fait à une complexité
“asymptotique“, qui sera une approximation du nombre
d’opérations élémentaires.
• Cela nous permettra d’avoir des calculs gérables sans pour

autant perdre en pertinence.
©
© SUPINFO
Fin de ce chapitre
©
© SUPINFO
3. COMPORTEMENT
ASYMPTOTIQUE DES FONCTIONS.
©
© SUPINFO
Plan de ce chapitre
a. Notations asymptotiques.
b. Croissance des fonctions usuelles.
c. Classes de complexité.
©
© SUPINFO
Hypothèses :
•Dans cette partie de généralités, on supposera que les

fonctions sont définies sur IN et à valeurs dans IR+.
•Ce n’est bien sûr pas une contrainte car les fonctions
exprimant une complexité sont nécessairement positives.
©
© SUPINFO
Borne supérieure asymptotique :
•On dit qu’une fonction f est un “grand O” d’une fonction g si

et seulement si :
$c > 0, $n0 > 0 / " n > n0 , f ( n) < c ´ g ( n)
•On note alors
f ( n ) =O ( g ( n ) )
©
© SUPINFO
Interprétation :
c x g(n)
f(n)
n0
f ( n ) =O ( g ( n) )
©
© SUPINFO
Exemples :
T ( n) =4 Þ T ( n ) =O ( 1)
T ( n) =4n +1 Þ T ( n) =O ( n)
T ( n) =4n +1 Þ T ( n ) =O ( n 2 )
©
© SUPINFO
Borne inférieure asymptotique :
•On dit qu’une fonction f est un “grand Omega” d’une

fonction g si et seulement si :
$c > 0, $n0 > 0 / " n > n0 , c ´ g ( n) < f ( n)
•On note alors
f ( n) =W ( g ( n ) )
©
© SUPINFO
Interprétation :
f(n)
c x g(n)
n0
f ( n) =W ( g ( n ) )
©
© SUPINFO
Exemples :
T ( n ) =4 Þ T ( n ) =W ( 1)
T ( n) =4n +1 Þ T ( n) =W ( n)
2
T ( n ) =4n +1 Þ T ( n) =W ( n)
©
© SUPINFO
Borne asymptotique :
•On dit qu’une fonction f est un “grand Theta” d’une fonction

g si et seulement si :
$c1 > 0, $c2 > 0, $n0 > 0 / " n > n0 , c1 ´ g ( n) < f ( n ) < c2 ´ g ( n)
•On note alors
f ( n) =Q ( g ( n ) )
©
© SUPINFO
Remarque :
•On se persuade vite que
f ( n ) =Q ( g ( n ) )
•Si et seulement si
f ( n) =O ( g ( n) ) et f ( n ) =W ( g ( n ) )
©
© SUPINFO
Interprétation :
c2 x g(n)
f(n)
c1 x g(n)
n0
f ( n ) =Q ( g ( n) )
©
© SUPINFO
Exemples :
T ( n ) =4 Þ T ( n ) =Q ( 1)
T ( n) =4n +1 Þ T ( n) =Q ( n)
T ( n ) =4n 2 +1 Þ T ( n ) =Q ( n 2 )
©
© SUPINFO
Équivalence :
•On dit qu’une fonction f est équivalente à une fonction g si

et seulement si :
f ( n)
lim n® +¥ =1
g ( n)
•On note alors :
f ( n) » g ( n)
©
© SUPINFO
Exemples :
f ( n) =4n +1, g ( n) =4n - 7 Þ f ( n) » g ( n)

( )
f n =4n - 2n +1, g n =4n 2
( ) 2
Þ ( ) ( )
f n »g n
©
© SUPINFO

Relation entre les fonctions logarithmes :
" a, b >1, log a ( n) =Q ( log b ( n) )
©
© SUPINFO

Croissance de la fonction factorielle :
•Formule de Stierling
n
æn ö
n! » 2p n ç ÷
èe ø
©
© SUPINFO

Croissances comparées : les fonctions
f1 ( n) =1 f2 ( n) =log ( n) f3 ( n) =n f4 ( n) =n. log ( n)
f5 ( n) =n 2 f6 ( n) =n3 f7 ( n) =2 n f8 ( n) =n!
sont classées de telle sorte que :
" i Î { 1,..., 7} , fi ( n) =O ( fi+1 ( n) )
©
© SUPINFO
©
© SUPINFO
• On va exprimer nos complexités algorithmiques comme
des “grands O” de fonctions de référence.
• Cela va permettre de classer les complexités.
• Des algorithmes appartenant à une même classe seront

alors considérés comme de complexité équivalente.
©
© SUPINFO
Complexités de référence :
O Type de complexité
O(1) constant
O(log n) logarithmique
O(n) linéaire
O(n * log n) quasi - linéaire
O(n2) quadratique
O(n3) cubique
O(2n) exponentiel
O(n!) factoriel
©
© SUPINFO
Exemples :
•Le calcul de la somme des n premiers entiers à l’aide d’une

formule explicite est donc de complexité constante.
•Ce même calcul réalisé de façon itérative est de complexité

linéaire.
•Le tri par sélection est de complexité quadratique.
©
© SUPINFO
Fin de ce chapitre
©
© SUPINFO
Complexité des algorithmes récursifs.
©
© SUPINFO

Langue

01 - Notion de Complexité Algorithmique

Transféré par

Informations du document

Titre original

Copyright

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

01 - Notion de Complexité Algorithmique

Titre original :

Transféré par

Droits d'auteur :

Notion de complexité algorithmique.

2ADS Advanced Algorithms

• Présenter les principales classes de complexité.

• Effectuer des premiers calculs de complexité.

1. Généralités sur la complexité.

a. But d’un calcul de complexité.

a. But d’un calcul de complexité.

•Comparer l’efficacité d’algorithmes résolvant le même

•Établir lequel de ces algorithmes est donc le plus optimal.

a. But d’un calcul de complexité.

Elles doivent être indépendantes :

•Du langage de programmation.

a. But d’un calcul de complexité.

• Le premier réflexe qui consisterait à « coder » les

• Il ne vérifie en effet pas les contraintes précédentes.

a. But d’un calcul de complexité.

• On va effectuer des calculs sur l’algorithme en lui même,

• Les résultats de ces calculs fourniront une estimation du

a. But d’un calcul de complexité.

• Le premier à avoir systématisé le fait de calculer la

b. Les deux types de complexité.

•Décompte du nombre d’opérations élémentaires

•Hypothèse de base : toutes les opérations élémentaires sont

b. Les deux types de complexité.

•Le temps d’exécution sera ainsi proportionnel au nombre

•Ce décompte est donc une “bonne” définition de la

b. Les deux types de complexité.

• Taille nécessaire pour stocker les différentes structures de

• On s’intéressera peu à cette question dans la suite du

c. De quoi est fonction la complexité ?

• En fonction de la taille des données passées en

• Par exemple pour un algorithme de tri, ce sera le nombre

c. De quoi est fonction la complexité ?

La complexité en temps d’un algorithme sera donc une

c. De quoi est fonction la complexité ?

•Souvent la complexité dépendra de la donnée en elle même

c. De quoi est fonction la complexité ?

•On parcourt un par un les éléments jusqu’à trouver le “bon”.

•Ce parcours peut s’arrêter dès le début si le premier

•Mais on peut également être amené à parcourir le tableau

c. De quoi est fonction la complexité ?

• Complexité « dans le meilleur des cas ».

• Complexité « dans le pire des cas ».

• Complexité « en moyenne ».

On calculera le plus souvent la complexité « dans le pire des

c. De quoi est fonction la complexité ?

•Si la donnée en elle même est un nombre entier, la façon de

•Par exemple si n = 4096 on peut considérer que la taille de n

d. Quelques calculs de sommes usuelles

d. Quelques calculs de sommes usuelles

d. Quelques calculs de sommes usuelles

d. Quelques calculs de sommes usuelles

d. Quelques calculs de sommes usuelles

e. Rappels sur la fonction logarithme.

" x, y > 0, log a ( xy) =log a ( x ) + log a ( y)

e. Rappels sur la fonction logarithme.

•Si a = e, il s’agit du logarithme népérien, noté ln.

•Si a = 2, il s’agit du logarithme binaire.

•Si a = 10, il s’agit du logarithme décimal.

e. Rappels sur la fonction logarithme.

e. Rappels sur la fonction logarithme.

e. Rappels sur la fonction logarithme.

e. Rappels sur la fonction logarithme.

Avez – vous des questions ?