Informatique

Cours 2

Performances algorithme

1 Critres de performances
Plusieurs critres peuvent tre utiliss pour quantifier les performances d'un algorithme :
- terminaison (il se termine),
- correction (il permet d'obtenir le rsultat attendu),
- complexit (rapidit d'excution ou espace mmoire ncessaire).
Preuve
Il s'agit en gnral de faire une preuve par rcurrence (preuve de terminaison ou de correction):
- l'algorithme vrifie une proprit avec les valeurs initiales,
- si l'algorithme vrifie la proprit la
itration alors on montre qu'il la vrifi galement la
( + 1) itration,
- le rsultat renvoy, au final, par l'algorithme vrifie la proprit.
En informatique, il est peu frquent de prouver mathmatiquement qu'un algorithme renvoie bien le
rsultat attendu ou se termine effectivement .
Certaines applications de scurit pour lesquelles aucun bug ne peut tre envisag sont prouves
mathmatiquement.
Exemple : le logiciel de vol de airbus A380 a t entirement prouv.

Contre-exemple : sur l'avion de chasse amricain F16, un pilote a

malencontreusement ferm le train d'atterrissage alors que l'avion
tait pos. Le logiciel de vol n'avait prvu de bloquer cette
ventualit.
Pratique
En pratique, on se contente souvent de vrifier que l'algorithme donne le bon rsultat :
- avec la valeur initiale,
- avec une valeur intermdiaire et ventuellement avec la plus grande valeur.
Cela n'est pas une preuve et des alas sont encore possibles pour des configurations non testes. Si le
programme est suffisamment simple, cela reste nanmoins une bonne garantie.

2 Terminaison
On souhaite gnralement qu'un algorithme se termine sauf s'il s'agit de l'algorithme d'un systme
devant fonctionner jusqu' sa mise hors tension (programme interne d'une carte d'acquisition par
exemple).
Pour un algorithme rcurrent ou pour une boucle conditionnelle while, la bonne pratique est de faire en
sorte que l'indice d'appel soit toujours infrieur l'indice en cours et de traiter la valeur initiale.

Lyce Jules Ferry Cannes

Page 1 sur 5

TSI2

Informatique

Cours 2

Performances algorithme

PREUVE DE TERMINAISON
Idalement lors d'oprations rptitives, on utilise un variant
jusqu' tre nul.

de boucle (entier positif) qui dcroit

Exemple :
# Entre :
un tableau T de n nombres tris par ordre croissant T[0..n-1]
#
un nombre x
# Sortie :
un tableau T de nombres tris par ordre croissant T[0..n] contenant x
T=[ 0 , 1.5 , 1.7 , 2] # valeur initiale de la table T
x=1.6
# nombre insrer T
i= len(T)-1
# i est affect du numro de dernier indice de T
T=T+ [ x ]
# on ajoute un lment la liste T (par dfaut x est suppos le plus grand)
while (T[i] > x and i > 0) :
T[i+1] T[i]
T[i]=x
i i-1
print ( 'Nouvelle liste trie :', T)
i est un variant de boucle : entier positif et qui dcroit chaque boucle jusqu' la valeur 0
(sauf si x est effectivement le plus grand lment, dans ce dernier cas les instructions de
la boucle while ne sont jamais excutes).
Dans les cas simples, la preuve de terminaison peut-tre obtenue mais cela n'est pas toujours le cas.
Contre-exemple : la suite de Syracuse

La dfinition de la suite est assez simple et semble en pratique se terminer mais cela n'a pas
encore t prouv mathmatiquement.

3 Correction
La correction consiste prouver que l'algorithme renvoie bien le rsultat attendu.
PREUVE :
Mathmatiquement on peut prouver si une algorithme dlivre bien le rsultat attendu partir d'un

invariant de boucle :
- proprit vraie lors de l'initialisation,
- proprit vraie pour la valeur du variant de boucle suivante si elle est vraie pour la prcdente,
- proprit vraie en fin de boucle et qui montre que le rsultat est bien celui attendu.
L'invariant de boucle est souvent difficile trouver.
Exemple : l'invariant de boucle de l'algorithme prcdent est :
la juxtaposition des tableaux T[0, i] et T[i+ 2, n+1] est gale au tableau initial et x est plus petit
que tous les lments du deuxime tableau.
Solution pratique pour vrifier que l'algorithme donne les rsultats attendus : tester avec des valeurs
particulires (mais ce n'est pas une preuve).
Exemple : -1, 1.6 puis 3 permettraient de vrifier que l'algorithme classe correctement les valeurs.
Lyce Jules Ferry Cannes

Page 2 sur 5

TSI2

Informatique

Cours 2

Performances algorithme

4 Complexit
4.1 Complexit dans le temps
La complexit dans le temps est le temps que prend l'excution d'un algorithme.
Cette complexit est trs variable d'une machine l'autre.
La complexit est donc exprime en nombres
effectuer pour calculer la valeur de la suite au rang n.

d'oprations (addition, multiplication)

Dans les calculs de complexit venir :

- on nglige la dure des oprations d'affectation ou d'incrmentation par rapport aux oprations
arithmtiques,
- on utilise la suite C(n) pour quantifier la complexit du calcul de u(n).
Exemple : suite

avec

2.

Dfinition itrative
def u(n):
r=2
for k in range(n):
r=0.5*(r + 3.0/r)
return(r)
Complexit : C(n)=3*n
Dfinition rcursive :
def u(n):
if (n==0):
return(2)
else:
x=u(n-1)
return( 0.5 * ( x + 3.0/x ) )

Complexit : C(0)=0 C(n)=C(n-1)+3 suite arithmtique : C(n)=3*n

Les mthodes itrative et rcursive ont priori la mme complexit en temps.
Dfinition rcursive "nave" :
def u(n):
if (n==0):
return(2)
else:
return( 0.5 * ( u(n-1) + 3.0/u(n-1) ) )
Complexit : C(n)=C(n-1) + C(n-1) +3 = 2.C(n-1)+3
Lyce Jules Ferry Cannes

suite arithmtico-gomtrique C(n)=

Page 3 sur 5

TSI2

Informatique

Cours 2

Performances algorithme

Figure 1 : Ordre de grandeur du temps d'excution d'un algorithme selon sa complexit (source Wikipedia)

On constate donc que pour n=50, la dure d'excution :

- de complexit constante (quelques oprations) est de l'ordre de 10ns (fonction explicite),
- d'une complexit logarithmique est aussi rapide : 10ns (dichotomie),
- d'une complexit linaire mettra 0,5ms (fonction itrative ou rcursive : exemple prcdent, ou
recherche dans un tableau une dimension),
- d'une complexit quasi linaire n.log mettra 0,5ms (association d'algorithmes combinant leurs
rsultats sur des problmes plus petits pour obtenir la solution gnrale).
- d'une complexit quadratique en n vaut 0,5 ms mais devient problmatique partir de 10 000
(2 boucles imbriques)
- d'une complexit exponentielle en 2 mettra 130 jours (fonction rcursive nave de l'exemple
prcdent). Cela rend rapidement inoprant de tels algorithmes lorsque n devient grand.
Enfin la complexit de l'algorithme devient significative lorsque n devient important (pour quelques
itrations la dure d'excution est ngligeable).
Mme avec la loi de Moore (qui prvoit un doublement de la puissance de calcul tous les 18 mois), il
n'est pas encore envisageable court terme de pouvoir raliser des produits matriciels de matrices
carres de ct 1000 000 (complexit ).
L'optimisation des algorithmes est encore d'actualit pour le traitement de grands volumes de donnes.

4.2 Complexit en mmoire

La complexit en mmoire sur les ordinateurs est dsormais rarement problmatique.
Pour certaines applications embarques cela peut encore en tre une limite.
Concernant les exemples prcdents :
- fonction explicite : une mmoire,
- fonction rcurrente : n mmoires.

Ressources :
Damien Broizat
Patrick Beynet UPSTIhttps://www.u-picardie.fr/~furst/docs/4-Complexite.pdf
https://fr.wikipedia.org/wiki/Analyse_de_la_complexit%C3%A9_des_algorithmes
http://www.enseignement.polytechnique.fr/profs/informatique/Francois.Morain/ TC/ X2004/Poly/www-poly009.html

Lyce Jules Ferry Cannes

Page 4 sur 5

TSI2

Informatique

Cours 2

Performances algorithme

Annexe : complexit de quelques algorithmes

Complexit logarithmique
Relation : C(n) = C(n/2) + b
Solution : C(n) = C(1) + b.log2(n) = (ln(n))
Exemples :
limination de la moiti des lments en temps constant avant l'appel rcursif,
recherche dichotomique rcursive,
exponentiation rapide
Complexit linaire
Relation : C(n) = C(n-1) + b (suite arithmtique)
Solution : C(n) = C(0) + b.n = (n)
Exemples :
factorielle,
recherche squentielle (balayage) rcursive dans un tableau
Relation : C(n) = C(n/2) + a.n + b
Solution : C(n) = (n)
Exemples :
traitement linaire avant l'appel rcursif dichotomique
Complexit quasi-linaire
Relation : C(n) = 2.C(n/2) + a.n + b
Solution : C(n) = (n.ln(n))
Exemples :
traitement linaire avant double appel rcursif dichotomique,
tri fusion
Complexit quadratique
Relation : C(n) = C(n-1) + a.n + b
Solution : C(n) = C(0) + a.n.(n+1)/2 + n.b = (n)
Exemples :
traitement en cout linaire avant l'appel rcursif,
tri bulle
Complexit en puissance de n
Relation : C(n) = a.C(n/2) + b, a 1
#
#
( )
( )
Solution : ( )
. (1)
+
= (
)
Exemples :
rptition a fois d'un traitement sur le rsultat de l'appel rcursif dichotomique

Complexit exponentielle
Relation : C(n) = a.C(n-1) + b, a 1 (suite arithmtico-gomtrique)
#
#
(0)
Solution : ( ) $
+
= ($ )
Exemples :
rptition a fois d'un traitement sur le rsultat de l'appel rcursif
Lyce Jules Ferry Cannes

Page 5 sur 5

TSI2