Partie 2

Outils danalyse

Outils danalyse

53

Plan

1. Correction dalgorithmes
2. Complexite algorithmique

Outils danalyse

54

Plan
1. Correction dalgorithmes
Introduction
Algorithmes iteratifs
Algorithmes recursifs
2. Complexite algorithmique
Introduction
Notations asymptotiques
Complexite dalgorithmes et de probl`emes
Complexite dalgorithmes iteratifs
Complexite dalgorithmes recursifs

Outils danalyse

55

Analyse dalgorithmes

Questions `a se poser lors de la definition dun algorithme :

Mon algorithme est-il correct ?
Mon algorithme est-il efficace ?
Autre question importante seulement marginalement abordee dans ce
cours :
Modularite, fonctionnalite, robustesse, facilite dutilisation, temps de
programmation, simplicite, extensibilite, fiabilite, existence dune
solution algorithmique...

Outils danalyse

56

Correction dun algorithme

La correction dun algorithme setudie par rapport `a un probl`eme
donne
Un probl`eme est une collection dinstances de ce probl`eme.
I
I

Exemple de probl`eme : trier un tableau

Exemple dinstance de ce probl`eme : trier le tableau [8, 4, 15, 3]

Un algorithme est correct pour une instance dun probl`eme sil

produit une solution correcte pour cette instance
Un algorithme est correct pour un probl`eme sil est correct pour
toutes ses instances (on dira quil est totalement correct)
On sinteressera ici `a la correction dun algorithme pour un probl`eme
(et pas pour seulement certaines de ses instances)

Outils danalyse

57

Comment verifier la correction ?

Premi`ere solution : en testant concr`etement lalgorithme :
I
I
I

Suppose dimplementer lalgorithme dans un langage (programme) et

de le faire tourner
Supppose quon peut determiner les instances du probl`eme `a verifier
Il est tr`es difficile de prouver empiriquement quon na pas de bug

Deuxi`eme solution : en derivant une preuve mathematique formelle :

I
I

Pas besoin dimplementer et de tester toutes les instances du

probl`eme
Sujet `a des bugs egalement

En pratique, on combinera les deux

Outils pour prouver la correction dun algorithme :
I
I

Outils danalyse

Algorithmes iteratifs : triplets de Hoare, invariants de boucle

Algorithmes recursifs : preuves par induction

58

Assertion
Relation entre les variables qui est vraie `a un moment donne dans
lexecution
Assertions particuli`eres :
I
I

Pre-condition P : conditions que doivent remplir les entrees valides de

lalgorithme
Post-condition Q : conditions qui expriment que le resultat de
lalgorithme est correct

P et Q definissent resp. les instances et solutions valides du

probl`eme
Un code est correct si le triplet (de Hoare) {P} code {Q} est vrai.
Exemple :

{x

Outils danalyse

0}y = sqrt(x){y 2 == x}

59

Correction : sequence dinstructions

{P}
S1
S2
...
Sn
{Q}

Pour verifier que le triplet est correct :

on ins`ere des assertions P1 , P2 , . . . , Pn decrivant letat des variables
`a chaque etape du programme
on verifie que les triplets {P} S1 {P1 }, {P1 } S2 {P2 }, . . .,
{Pn 1 } Sn {Q} sont corrects
Trois types dinstructions : aectation, condition, boucle

Outils danalyse

60

Correction : aectations

{P}
x =e
{Q}

Pour prouver que le triplet est correct, il faut montrer quon peut deriver
Q `a partir de P en remplacant x par e.
Exemple :
{x = = 2}
y = x +1
{y = = 3}

Outils danalyse

61

Correction : conditions
{P}
if B
C1
else
C2
{Q}

Pour prouver que le triplet est correct, on doit prouver que

{P et B} C1 {Q}
{P et non B} C2 {Q}
sont corrects
Exemple :
{x < 6}
if x < 0
y =0
else
y =x
{0 y < 6}
Outils danalyse

62

Correction : boucles
{P}
INIT
while B
CORPS
FIN
{Q}

{P}
INIT
{I }
while B
{I et B} CORPS {I }
{I et non B}
FIN
{Q}

Pour prouver que le triplet est correct :

On met en evidence une assertion particuli`ere I , appelee invariant de
boucle, qui decrit letat du programme pendant la boucle.
On prouve que :
I
I
I

{P} INIT {I } est correct

{I et B} CORPS {I } est correct
{I et non B} FIN {Q} est correct

Si on a plusieurs boucles imbriquees, on les traite separement, en

demarrant avec la boucle la plus interne.
Outils danalyse

63

Correction : terminaison de boucle

INIT
while B
CORPS
FIN

Un fois quon a prouve que le triplet etait correct, il faut encore

montrer que la boucle se termine
Pour prouver la terminaison, on cherche une fonction de terminaison
f :
I
I
I

definie sur base des variables de lalgorithme et `a valeur enti`ere

naturelle ( 0)
telle que f decrot strictement suite `a lexecution du corps de la
boucle
telle que B implique f > 0

Puisque f decrot strictement, elle finira par atteindre 0 et donc `a

infirmer B.
Outils danalyse

64

Exemple : Fibonacci-iter

Fibonacci-Iter(n)
if n 1
return n
else
pprev = 0
prev = 1
for i = 2 to n
f = prev + pprev
pprev = prev
prev = f
return f

Proposition : Si n 0,
Fibonacci-iter(n) renvoie
Fn .
Outils danalyse

Reecriture, post- et
pre-conditions
Fibonacci-Iter(n)
{n 0} // {P}
if n 1
prev = n
else
pprev = 0
prev = 1
i =2
while (i n)
f = prev + pprev
pprev = prev
prev = f
i = i +1
{prev == Fn } // {Q}
return prev
65

Exemple : Fibonacci-iter

Analyse de la boucle

Analyse de la condition

{n > 1}
pprev = 0
prev = 1
i =2
{pprev == Fi 2 , prev == Fi
correct

{n 0 et n 1}
prev = n
{prev == Fn }

correct (F0 = 0, F1 = 1)
{n 0 et n > 1}
pprev = 0
prev = 1
i =2
while (i n)
f = prev + pprev
pprev = prev
prev = f
i = i +1
{prev == Fn }
I = {pprev = = Fi
Outils danalyse

2 , prev

= = Fi

{pprev = = Fi 2 , prev = = Fi
f = prev + pprev
pprev = prev
prev = f
i = i +1
{pprev = = Fi 2 , prev = = Fi

1, i

{pprev = = Fi 2 , prev = = Fi
{prev = = Fn }

1, i

correct

1}

1}

n}

1}

= = n + 1}

correct

66

Exemple : Fibonacci-iter
i =2
while (i n)
f = prev + pprev
pprev = prev
prev = f
i = i +1
Fonction de terminaison f = n
I
I

i +1 :

i n )f =n i +1>0
i = i + 1 ) f diminue `a chaque iteration

Lalgorithme est donc correct et se termine.

Outils danalyse

67

Exemple : tri par insertion

Insertion-Sort(A)
1 for j = 2 to A.length
2
key = A[j]
3
// Insert A[j] into the sorted sequence A[1 . . j
4
i =j 1
5
while i > 0 and A[i] > key
6
A[i + 1] = A[i]
7
i =i 1
8
A[i + 1] = key

1].

Demontrons informellement que la boucle externe est correcte

Invariant I : le sous-tableau A[1 . . j 1] contient les elements du
tableau original A[1 . . j 1] ordonnes.

Outils danalyse

68

Exemple : tri par insertion

j =2
for j = 2 to A.length
while i A.length
,
...
...
j = j +1
P =A est un tableau de taille A.length,
Q =Le tableau A est trie,
I =A[1 . . j 1] contient les j 1 premiers elements de A tries
{P}j = 2{I }
I

Outils danalyse

(avant la boucle)

j = 2 ) A[1] est trivialement ordonne

69

Exemple : tri par insertion

{I et j A.length} CORPS {I }
I
I
I

(pendant la boucle)

La boucle interne deplace A[j 1], A[j 2], A[j 3] . . . dune position
vers la droite jusqu`a trouver la bonne position pour key (A[j]).
A[1 . . j] contient alors les elements originaux de A[1 . . j] tries.
j = j + 1 retablit linvariant

{I et j = A.length + 1}{Q}
I

Fonction de terminaison f = A.length

Outils danalyse

(apr`es la boucle)

Puisque j = A.length + 1, linvariant implique que A[1 . . A.length] est

ordonne.

j +1

70

Invariant
Un invariant peut etre difficile `a trouver pour certains algorithmes
En general, lalgorithme decoule de linvariant et pas linverse
I
I

Fibonacci-iter : On calcule iterativement Fi 1 et Fi 2

(I = {pprev == Fi 2 , prev == Fi 1 })
Insertion-sort : On ajoute lelement j aux j 1 premiers elements
dej`a tries
(I =A[1 . . j 1] contient les j 1 premiers elements de A tries)

La preuve par invariant est basee sur le principe general de preuve

par induction quon va utiliser aussi pour prouver la correction des
algorithmes recursifs
Initialisation

Maintenance
It. 1

Outils danalyse

It. 2

It. 3

Terminaison
It. 4

It. 5

71

Preuve par induction

Cas$induc,f$

Cas$de$base$

On veut montrer quune propriete est vraie pour une serie

dinstances
On suppose lexistence dun ordonnancement des instances
Cas de base : on montre explicitement que la propriete est vraie
pour la ou les premi`eres instances
Cas inductif : on suppose que la propriete est vraie pour les k
premi`eres instances et on montre quelle lest alors aussi pour la
k + 1-i`eme instance (quel que soit k)
Par le principe dinduction, la propriete sera vraie pour toutes les
instances
Outils danalyse

72

Preuve par induction : exemple

Proposition : Pour tout n

0, on a
n
X
i=1

i=

n(n + 1)
2

Demonstration :
P
Cas de base : n = 0 ) 0i=1 i = 0 = 0(0+1)
2
Cas inductif : Supposons la propriete vraie pour n et montrons
quelle est vraie pour n + 1 :
!
n+1
n
X
X
n(n + 1)
i =
i + (n + 1) =
+ (n + 1)
2
i=1

i=1

(n + 1)(n + 2)
2

Par induction, le propriete est vraie pour tout n.

Outils danalyse

73

Correction dalgorithmes recursifs par induction

Propriete `a montrer : lalgorithme est correct pour une instance

quelconque du probl`eme
Instances du probl`eme ordonnees par taille (taille du tableau,
nombre de bits, un entier n, etc.)
Cas de base de linduction = cas de base de la recursion
Cas inductif : on suppose que les appels recursifs sont corrects et on
en deduit que lappel courant est correct
Terminaison : on montre que les appels recursifs se font sur des
sous-probl`emes (souvent trivial)

Outils danalyse

74

Exemple : Fibonacci
Fibonacci(n)
1 if n 1
2
return n
3 return Fibonacci(n

2) + Fibonacci(n

1)

Proposition : Pour tout n, Fibonacci(n) renvoie Fn .

Demonstration :
Cas de base : pour n = 0, Fibonacci(n) renvoie F0 = 0. For n = 1,
Fibonacci(n) renvoie F1 = 1.
Cas inductif :
I
I

Supposons n 2 et que pour tout 0 m < n, Fibonacci(m)

renvoie Fm .
Pour n 2, Fibonacci(n) renvoie
Fibonacci(n
= Fn

2 + Fn

2) + Fibonacci(n

1)

(par hypoth`ese inductive)

= Fn .
Outils danalyse

75

Exemple : merge sort

merge-sort(A, p, r )
1 if p < r
2
q = b p+r
2 c
3
merge-sort(A, p, q)
4
merge-sort(A, q + 1, r )
5
merge(A, p, q, r )

Proposition : Pour tout 1 p r A.length, merge-sort(A, p, r ) trie

le sous-tableau A[p . . r ].
(On supposera que Merge est correct mais il faudrait le demontrer par
un invariant)

Outils danalyse

76

Exemple : merge sort

merge-sort(A, p, r )
1 if p < r
2
q = b p+r
2 c
3
merge-sort(A, p, q)
4
merge-sort(A, q + 1, r )
5
merge(A, p, q, r )

Demonstration :
Cas de base : pour r p = 0, merge-sort(A, p, r ) ne modifie pas
A et donc A[p] = A[q] est trivialement trie
Cas inductif :
I
I

Outils danalyse

Supposons r p > 0 et que pour tout 1 p 0 r 0 A.length tels

que r 0 p 0 < r p, merge-sort(A, p 0 , r 0 ) trie A[p 0 . . r 0 ]
Les appels merge-sort(A, p, q) et merge-sort(A, q + 1, r ) sont
corrects par hypoth`ese inductive (puisque q p < r p et
r q + 1 < r p)
En supposant Merge correct, merge-sort(A, p, r ) est correct.
77

Conclusion sur la correction

Preuves de correction :
I
I

Algorithmes iteratifs : invariant (=induction)

Algorithmes recursifs : induction

Malheureusement, il nexiste pas doutil automatique pour verifier la

correction (et la terminaison) dalgorithmes
Dans la suite, on ne presentera des invariants ou des preuves par
induction que tr`es sporadiquement lorsque ce sera necessaire (cas
non triviaux)

Outils danalyse

78

Plan
1. Correction dalgorithmes
Introduction
Algorithmes iteratifs
Algorithmes recursifs
2. Complexite algorithmique
Introduction
Notations asymptotiques
Complexite dalgorithmes et de probl`emes
Complexite dalgorithmes iteratifs
Complexite dalgorithmes recursifs

Outils danalyse

79

Performance dun algorithme

Plusieurs metriques possibles :
I
I
I
I
I

Longueur du programme (nombre de lignes)

Simplicite du code
Espace memoire consomme
Temps de calcul
...

Les temps de calcul sont la plupart du temps utilises

I
I

Ils peuvent etre quantifies et sont faciles `a comparer

Souvent ce qui compte reellement

Nous etudierons aussi lespace memoire consomme par nos

algorithmes

Outils danalyse

80

Comment mesurer les temps dexecution ?

Experimentalement :
On ecrit un programme qui implemente lalgorithme et on lexecute
sur des donnees
Probl`emes :
I
I

Les temps de calcul vont dependre de limplementation : CPU, OS,

langage, compilateur, charge de la machine, OS, etc.
Results
Sur quels donnees tester lalgorithme ?
60

Time (seconds)

50
40
30

Ruby
Python
Scheme
C
C-wiz
Java
C-gcc

20
10
0
20

25

30

35

40

45

50

n
2006

Outils danalyse

Antonio Carzaniga

(Carzaniga)
81

Comment mesurer les temps dexecution ?

En se basant sur un mod`ele de calcul abstrait :
Random-access machine (RAM) :
I

Types de donnees de base :

I
I

Operations de base de la machine :

I
I
I
I

I
I

Outils danalyse

Entiers et nombres flottants

Chaque mot est de taille limitee (par ex, 64 bits)
addition, soustraction, multiplication...
aectation, acc`es `
a un element dun tableau...
branchement conditionnel, saut
appel de sous-routines, renvoi dune valeur

Les operations sont executees les unes apr`es les autres (pas de
parallelisme)
Les operations de base prennent un temps constant

82

Comment mesurer les temps dexecution ?

Calculer les temps de calcul = sommer le temps dexecution associe
`a chaque instruction du pseudo-code
Mod`ele RAM :
I
I

Operations de base : temps constant

Appel de sous-routines : temps de lappel (constant) + temps de
lexecution de la sous-routine (calcule recursivement)

Le temps depend de lentree (linstance particuli`ere du probl`eme)

On etudie generalement les temps de calcul en fonction de la
taille de lentree
I
I

Outils danalyse

Generalement, le nombre de valeurs pour la decrire

Mais ca peut etre autre chose (Ex : n pour Fibonacci)

83

Chapter 2 Getting Started

Analyse du tri par insertion

I NSERTION -S ORT .A/

1 for j D 2 to A:length
2
key D Aj !
3
// Insert Aj ! into the sorted
sequence A1 : : j ! 1!.
4
i D j !1
5
while i > 0 and Ai! > key
6
Ai C 1! D Ai!
7
i D i !1
8
Ai C 1! D key

cost
c1
c2
0
c4
c5
c6
c7
c8

times
n
n!1
n!1
n
P! 1
n

t
PjnD2 j
.t ! 1/
PjnD2 j
.t
j D2 j ! 1/
n!1

running
of the
thewhile
sum of
tj = The
nombre
de time
fois que
la algorithm
conditionisdu
estrunning
testee.times for each sta
ment executed;
statement
thatun
takes
ci steps
execute
executes
Temps
executiona T
(n) (pour
tableau
detotaille
n) and
donn
e par : n times w

contribute ci n to the total running time.6 To compute

T .n/,
the running time
n
n
X
X
T (n) -S
= ORT
c1 n on
+ can
1) +
1) + we
c5 sum
tj +
(tj 1)
I NSERTION
ofc4n(nvalues,
thec6 products
of the cost
2 (ninput
j=2
j=2
times columns, obtaining
+c7

n
X
(tj

1) + c8 (n

1)

T .n/ D c1 n C c2j=2
.n ! 1/ C c4 .n ! 1/ C c5
Outils danalyse

n
X

j D2

n
X
tj C c6
.tj ! 1/
j D2

84

Dierents types de complexite

Meme pour une taille fixee, la complexite peut dependre de
linstance particuli`ere
Soit Dn lensemble des instances de taille n dun probl`eme et T (in )
le temps de calcul pour une instance in 2 Dn .
Sur quelles instances les performances dun algorithme devraient
etre jugees :
I
I
I

Cas le plus favorable (best case) : T (n) = min{T (in )|in 2 Dn }

Cas le plus defavorable (worst case) P
: T (n) = max{T (in )|in 2 Dn }
Cas moyen (average case) : T (n) = in 2Dn Pr (in )T (in ) o`
u Pr (in ) est
la probabilite de rencontrer in

On se focalise generalement sur le cas le plus defavorable

I
I

Outils danalyse

Donne une borne superieure sur le temps dexecution.

Le meilleur cas nest pas representatif et le cas moyen est difficile `a
calculer.

85

Analyse du tri par insertion

Meilleur cas :
le tableau est trie ) tj = 1.

Le temps de calcul devient :

T (n) = c1 n + c2 (n

1) + c4 (n

= (c1 + c2 + c4 + c5 + c8 )n

1) + c5 (n

1) + c8 (n

1)

(c2 + c4 + c5 + c8 )

T (n) = an + b ) T (n) est une fonction lineaire de n

Outils danalyse

86

Analyse du tri par insertion

Pire cas :
le tableau est trie par ordre decroissant ) tj = j.
Le temps de calcul devient :
T (n)

n(n + 1)
1
c1 n + c2 (n 1) + c4 (n 1) + c5
2

n(n 1)
n(n 1)
+c6
+ c7
+ c8 (n 1)
2
2
c5
c6
c7
c5
c6
c7
( +
+ )n2 + (c1 + c2 + c4 +
+ c8 )n
2
2
2
2
2
2
(c2 + c4 + c5 + c8 )

T (n) = an2 + bn + c ) T (n) est une fonction quadratique de n

Outils danalyse

87

Analyse asymptotique
On sinteresse `a la vitesse de croissance (order of growth) de T (n)
lorsque n crot.
I

Tous les algorithmes sont rapides pour des petites valeurs de n

On simplifie generalement T (n) :

I

en ne gardant que le terme dominant

I
I

Exemple : T (n) = 10n3 + n2 + 40n + 800

T(1000)=100001040800, 10 10003 = 100000000000

en ignorant le coefficient du terme dominant

I

Asymptotiquement, ca naecte pas lordre relatif

6

10

x 10

1000*N
4*N2

9
8

N3

0.01*2N

6
5
4
3
2
1
0

100

200

300

400

500
N

600

700

800

900

1000

Exemple : Tri par insertion : T (n) = an2 + bn + c ! n2 .

Outils danalyse

88

Pourquoi est-ce important ?

Supposons quon puisse traiter une operation de base en 1s.

Temps dexecution pour dierentes valeurs de n
T(n)
n
400n
2n2
n4
2n

n = 10
10s
4ms
200s
10ms
1ms

n = 100
0.1ms
40ms
20ms
100s
4 1016 annees

n = 1000
1ms
0.4s
2s
11.5 jours
3.4 10287 annees

n = 10000
10ms
4s
3.3m
317 annees
...
(Dupont)

Outils danalyse

89

Pourquoi est-ce important ?

Taille maximale du probl`eme quon peut traiter en un temps donne :
T(n)
n
400n
2n2
n4
2n

en 1 seconde
1 106
2500
707
31
19

en 1 minute
6 107
150000
5477
88
25

en 1 heure
3.6 109
9 106
42426
244
31

Si m est la taille maximale que lon peut traiter en un temps donne,

que devient cette valeur si on recoit une machine 256 fois plus
puissante ?
T(n)
n
400n
2n2
n4
2n

Temps
256m
256m
16m
4m
m+8
(Dupont)

Outils danalyse

90

Notations asymptotiques

Permettent de caracteriser le taux de croissance de fonctions

f : N ! R+
Trois notations :
I
I
I

Outils danalyse

Grand-O : f (n) 2 O(g (n)) f (n) g (n)

Grand-Omega : f (n) 2 (g (n)) f (n) g (n)
Grand-Theta : f (n) 2 (g (n)) f (n) = g (n)

91

Asymptotic notation
Notation grand-O

O-notation
O(g (n)) = {f (n)|9c > 0, 9n0 1 tels que 0 f (n) cg (n), 8n n0 }
O.g.n// D ff .n/ W there exist positive constants c and n0 su
0 " f .n/ " cg.n/ for all n # n0 g :
cg(n)

f(n)

n0

g.n/ is an asymptotic upper bound for f .n/.

f (n) 2 O(g (n)) ) g If

(n)
est2une
bornewesup
erieure
f .n/
O.g.n//,
write
f .n/ asymptotique
D O.g.n// (willpour
precisely
f (n).
Par abus de notation, on ecrira aussi : f (n) = O(g (n)).
Outils danalyse

92

Notation

n1:99999
grand-Omega
n2 = lg lg lg n
!-notation

(g (n)) = {f (n)|9c > 0, 9n0

1 tels que 0 cg (n) f (n), 8n

n0 }

!.g.n// D ff .n/ W there exist positive constants c and n0 such

0 ! cg.n/ ! f .n/ for all n " n0 g :
f(n)
cg(n)

n0

g.n/ is an asymptotic lower bound for f .n/.

f (n) 2 (g (n)) ) g (n) est une borne inferieure asymptotique pour

f (n).
Example
Par abus de notation,pnonDe!.lg
criran/,aussi
= n(g
(n)).
with :c fD(n)
1 and
0 D 16.
Outils danalyse

Examples of functions in !.n2 /:

93

Notation grand-Theta
Lecture Notes for Chapter 3: Growth of Functions

(g (n)) = {f (n)|9c
1
1 , c2 > 0, 9n0
-notation
tels que 0 c1 g (n) f (n) c2 g (n), 8n n0 }
.g.n// D ff .n/ W there exist positive constants c1 , c2 , and n
0 ! c1 g.n/ ! f .n/ ! c2 g.n/ for all n "
c2g(n)
f(n)
c1g(n)

n0

is an asymptotically tight bound for f .n/.

f (n) 2 (g (n)) ) gg.n/
(n) est
une borne serree (tight) asymptotique
pour f (n).
Par abus de notation,Example
on ecrira aussi : f (n) = (g (n)).
Outils danalyse

n2 =2 # 2n D .n2 /, with c1 D 1=4, c2 D 1=2, and n0 D 8.

94

Exemples
3n5 16n + 2 2 O(n5 ) ? 2 O(n) ? 2 O(n17 ) ?
3n5 16n + 2 2 (n5 ) ? 2 (n) ? 2 (n17 ) ?
3n5 16n + 2 2 (n5 ) ? 2 (n) ? 2 (n17 ) ?
2n + 100n6 + n 2 O(2n ) ? 2 (3n ) ? 2 (n7 ) ?
Classes de complexite :
O(1) O(log n) O(n) O(n log n) O(na>1 ) (2n )
500

2n
n3

450
400

n2
n.log(n)
n
log(n)

350
300
250
200
150
100
50
0

Outils danalyse

10

15

20

25

30

35

40

45

50

95

Quelques proprietes
f (n) 2 (g (n)) , g (n) 2 O(f (n))
f (n) 2 (g (n)) , f (n) 2 O(g (n)) et f (n) 2 (g (n))
f (n) 2 (g (n)) , g (n) 2 (f (n))
Si f (n) 2 O(g (n)), alors pour tout k 2 N, on a k f (n) 2 O(g (n))
I

Exemple : loga (n) 2 O(logb (n)), an+b 2 O(an )

Si f1 (n) 2 O(g1 (n)) et f2 (n) 2 O(g2 (n)), alors

f1 (n) + f2 (n) 2 O(g1 (n) + g2 (n)) et f1 (n) + f2 (n) 2 O(max{g1 (n), g2 (n)})
Pm
i
m
I Exemple :
i=1 ai n 2 O(n )
Si f1 (n) 2 O(g1 (n)) et f2 (n) 2 O(g2 (n)), alors
f1 (n) f2 (n) 2 O(g1 (n) g2 (n))

Outils danalyse

96

Complexite dun algorithme

On utilise les notations asymptotiques pour caracteriser la

complexite dun algorithme.
Il faut preciser de quelle complexite on parle : generale, au pire cas,
au meilleur cas, en moyenne...
La notation grand-O est de loin la plus utilisee
I

f (n) 2 O(g (n)) sous-entend generalement que O(g (n)) est le plus
petit sous-ensemble qui contient f (n) et que g (n) est la plus concise
possible
Exemple : n3 + 100n2 n 2 O(n3 ) = O(n3 + n2 ) O(n4 ) O(2n )

Idealement, les notations O et devraient etre limitees au cas o`

u
on na pas de borne serree.

Outils danalyse

97

Complexite dun algorithme

Exemples :
On dira :
La complexite au pire cas du tri par insertion est (n2 )
plutot que
La complexite au pire cas du tri par insertion est O(n2 )
ou La complexite du tri par insertion est O(n2 )
On dira
La complexite au meilleur cas du tri par insertion est (n)
plutot que
La complexite au meilleur cas du tri par insertion est (n)
ou La complexite du tri par insertion est (n)
Par contre, on dira La complexite de Fibonacci est (1.4n ), car
on na pas de borne plus precise `a ce stade.

Outils danalyse

98

Complexite dun probl`eme

Les notations asymptotiques servent aussi `a caracteriser la
complexite dun probl`eme
I
I
I

Un probl`eme est O(g (n)) sil existe un algorithme O(g (n)) pour le
resoudre
Un probl`eme est (g (n)) si tout algorithme qui le resoud est
forcement (g (n))
Un probl`eme est (g (n)) sil est O(g (n)) et (g (n))

Exemple du probl`eme de tri :

I
I
I

Le probl`eme du tri est O(n log n) (voir plus loin)

On peut montrer facilement que le probl`eme du tri est (n) (voir le
transparent suivant)
On montrera plus tard que le probl`eme de tri est en fait (n log n) et
donc quil est (n log n).

Exercice : montrez que la recherche du maximum dans un tableau

est (n)

Outils danalyse

99

Le probl`eme du tri est (n)

Preuve par labsurde (ou par contraposition) :
Supposons quil existe un algorithme moins que O(n) pour resoudre
le probl`eme du tri
Cet algorithme ne peut pas parcourir tous les elements du tableau,
sinon il serait au moins O(n)
Il y a donc au moins un element du tableau qui nest pas vu par cet
algorithme
Il existe donc des instances de tableau qui ne seront pas triees
correctement par cet algorithme
Il ny a donc pas dalgorithme plus rapide que O(n) pour le tri.

Outils danalyse

100

Comment calculer la complexite en pratique ?

Quelques r`egles pour les algorithmes iteratifs :

Aectation, acc`es `a un tableau, operations arithmetiques, appel de
fonction : O(1)
Instruction If-Then-Else : O(complexite max des deux branches)
Sequence doperations : loperation la plus couteuse domine (r`egle
de la somme)
Boucle simple : O(nf (n)) si le corps de la boucle est O(f (n))

Outils danalyse

101

Comment calculer la complexite en pratique ?

Double boucle : O(n2 f (n)) o`
u f (n) est la complexite du corps de la
boucle
Boucles incrementales : O(n2 ) (si corps O(1))
for i = 1 to n
for j = 1 to i
...

Boucles avec un increment exponentiel : O(log n) (si corps O(1))

i =1
while i n
...
i = 2i

Outils danalyse

102

Exemple :
prefixAverages(X ) :
Entr
ee : tableau X de taille n
Sortie : tableau A de taille n tel que A[i] =
prefixAverages(X )
1 for i = 1 to X .length
2
a=0
3
for j = 1 to i
4
a = a + X [j]
5
A[i] = a/i
6 return A

Complexite : (n2 )

Outils danalyse

Pi

j=1

X [j]

prefixAverages2(X )
1 s =0
2 for i = 1 to X .length
3
s = s + X [i]
4
A[i] = s/i
5 return A

Complexite : (n)

103

Complexite dalgorithmes recursifs

La complexite dalgorithme recursif m`ene generalement `a une

equation de recurrence
La resolution de cette equation nest generalement pas triviale
On se contentera detudier quelques cas particuliers importants dans
ce cours

Outils danalyse

104

Factorial et Fibonacci

Factorial(n)
1 if n = = 0
2
return 1
3 return n Factorial(n
T (0)

c0

T (n)

T (n

c1 n + c0

1) + c1

) T (n) 2 (n)

Outils danalyse

1)

Fib(n)
1 if n 1
2
return n
3 return Fib(n

2) + Fib(n

T (0)

c0 , T (1) = c0

T (n)

T (n

1) + T (n

1)

2) + c1

) T (n) 2 (1.4n )

105

Analyse du tri par fusion

merge-sort(A, p, r )
1 if p < r
2
q = b p+r
2 c
3
merge-sort(A, p, q)
4
merge-sort(A, q + 1, r )
5
merge(A, p, q, r )
Recurrence :
T (1) = c1

T (1) = (1)

T (n) = 2T (n/2) + c2 n + c3

T (n) = 2T (n/2) + (n)

Outils danalyse

106

Analyse du tri par fusion

2-16

Lecture Notes for Chapter 2: Getting Started

cn

Simplifions la recurrence en :
T (1) = c

cn/2

cn/2

T (n) = 2T (n/2) + cn
On peut representer la
recurrence par un arbre de
recursion

lg n
cn/4

cn/4

cn/4

cn/4

La complexite est la somme du

co
ut de chaque noeud
c

n
Outils danalyse

Total: cn l
107

Analyse du tri par fusion

2-16

Lecture Notes for Chapter 2: Getting Started

cn

cn

cn/2

Chaque niveau a un co
ut
cn

cn/2

cn

lg n

En supposant que n est

une puissance de 2, il y a
log2 n + 1 niveaux

cn/4

cn/4

cn/4

cn

cn/4

Le co
ut total est
cn log2 n + cn 2 (n log n)

cn

n
Total: cn lg n + cn
!

Each level has cost cn.

!
!

Outils danalyse

The top level has cost cn.

The next level down has 2 subproblems, each contributing cost
The next level has 4 subproblems, each contributing cost cn=4.
108

Remarques
Limitations de lanalyse asymptotique
Les facteurs constants ont de limportance pour des probl`emes de
petite taille
I

Le tri par insertion est plus rapide que le tri par fusion pour n petit

Deux algorithmes de meme complexite (grand-O) peuvent avoir des

proprietes tr`es dierentes
I

Le tri par insertion est en pratique beaucoup plus efficace que le tri
par selection sur des tableaux presque tries

Complexite en espace
Setudie de la meme mani`ere, avec les memes notations
Elle est bornee par la complexite en temps (pourquoi ?)

Outils danalyse

109

Ce quon a vu

Correction dalgorithmes iteratifs (par invariant) et recursifs (par

induction)
Notions de complexite algorithmique
Notations asymptotiques
Calcul de complexite dalgorithmes iteratifs et recursifs

Outils danalyse

110