COMPLEXITE

ALGORITHMIQUE

Mme S. BOUKERRAM
Née AIT KCI AZZOU

1
 COMPLEXITÉ ALGORITHMIQUE

Quel est le plus

Algo 1 Algo 2
efficace

2
 COMPLEXITE ALGORITHMIQUE

Le calcul de
la complexité d’un
algorithme permet de
mesurer sa performance.

3
4
 1 Annèe 2 Annèe 3 Annèe 4 Année 5 Annèe

JE VOIS MA CLASSE

5
1 Annèe 2 Annèe 3 Annèe 4 Année 5 Annèe

6
1 Annèe 2 3 Annèe 4 Année 5 Annèe CM1 CM2 CM3 CM4
Annèe

JE VOIS MA CLASSE

7
1 Annèe 2 3 Annèe 4 Année 5 Annèe CM1 CM2 CM3 CM4
Annèe

8
 1 2 3 4 5

Où est ma classe
CM4 ??

9
 1 2 3 4 5

10
1 2 3 4 5

11
1 2 3 4 5

12
1 2 3 4 5

13
1 2 3 4 5

Trouvé!!!

14
1 2 3 4 5 6 7 8 9

15
 1 2 3 4 5 6 7 8 9

16
1 2 3 4 5 6 7 8 9

17
1 2 3 4 5 6 7 8 9

18
1 2 3 4 5 6 7 8 9
J’ai trouvé

19
 1 2 3 4 5 6 7 8 9

LE MEILLEUR DES CAS LE MOYEN DES CAS LE PIRE DES CAS

20
 COMPLEXITE ALGORITHMIQUE

SOIT UN TABLEAU D’ENTIERS ; on veut rechercher une valeur val dans ce tableau

100 20 30 45 15 6 17 8 29

LE MOYEN DES CAS

LE MEILLEUR DES CAS LE PIRE DES CAS

21
La complexité de l’enfant est de déterminer le
temps nécessaire pour trouver sa classe parmi
toutes les classes

La complexité d’un algorithme est de

déterminer le temps nécessaire pour son
éxecution en fonction de la taille des données

23
 OBJECTIF DE LA COMPLEXITÉ

Evaluer l’efficacité des algorithmes

Optimiser les algorithmes

Comparer les algorithmes résolvant un même problème

Classer les problèmes selon leurs difficultés

24
 CALCUL DE LA COMPLEXITÉ

COMPLEXITÉ
Ressources

complexité
complexité spatiale :
temporelle

permet de quantifier
permet de quan3fier
l’utilisation de
le temps d’exécu3on
la mémoire
25
 TAILLE DES DONNÉES

Graphe (Plus Fonction

Tableau (Tri)
court chemin) (Calcul nk)

Paramètres
Dimension Nœuds
(entiers)

Arêtes

26
 COMPLEXITÉ TEMPORELLE

Evaluer le temps d’exécu2on d’un algorithme

en fonc2on de la longueur de l’énoncé

Comparer les performances de différents

algorithmes résolvant le même problème.

Evaluer la taille maximale des énoncés qu’un

algorithme peut traiter.

28
 PUISQU’IL S’AGIT SEULEMENT DE COMPARER DES
ALGORITHMES, LES RÈGLES DE CE CALCUL DOIVENT ÊTRE
INDÉPENDANTES :

Ø du langage de programmation utilisé

Ø du processeur de l’ordinateur sur lequel sera exécuté

le code

Ø de l’éventuel compilateur employé.

29
 CALCUL DE LA COMPLEXITÉ
TEMPORELLE

Complexité algorithmique temporelle (en temps)

d’un algorithme A: compte le nombre
d’opérations élémentaires effectuées par
l’algorithme A en fonction de la taille des
données n, indépendamment de la machine et du
langage utilisé, exprimé par CoûtA(n).

30

de la taille des données n
plus ces données seront
volumineuses, plus il faudra
d’opérations élémentaires pour
les traiter.
La complexité en temps d’un
algorithme sera exprimé
par une fonction,
notée 𝑇 (pour Time), qui
dépend :
de la nature des donnée Nombre d'instructions
de la façon dont sont répar9es
On notera 𝑛 le nombre de
les différentes valeurs qui la
données à traiter.
cons9tuent.
31
LES INSTRUCTIONS ÉLÉMENTAIRES

les opéra*ons arithmé*ques (addi*on,

soustrac*on, mul*plica*on, division, modulo,
par*e en*ère, . . .)

la comparaisons de données (rela*on d’égalité,

d’infériorité, . . .)

le transferts de données (lecture et écriture dans

un emplacement mémoire)

les instructions de contrôle (if,elif,else,

while,for ) Affectation
32
 PAR EXEMPLE

SOIT UN TABLEAU D’ENTIERS ; on veut rechercher une valeur val dans ce tableau

100 20 30 45 15 6 17 8 29

LE MEILLEUR DES CAS LE MOYEN DES CAS

LE PIRE DES CAS

34
Définitions On note Dn l'ensemble des données de taille n et T(d) le coût
de l'algorithme sur la donnée d.
On définit 3 types de complexité :

Complexité au meilleur : C'est le plus petit nombre

d'opérations qu'aura à exécuter l'algorithme sur un jeu de
données de taille fixée, ici à n.

Complexité au pire : max (n) = max( T(d))

C'est le plus grand nombre d'opérations qu'aura à exécuter
l'algorithme sur un jeu de données de taille fixée, ici à n.

Complexité e n moyenne : C'est la moyenne des

complexités de l'algorithme sur des jeux de données de taille n.
∑#∈%& "($)
Tmoy(n)=
&'

35

Un algorithme est dit optimal si
sa complexité est la complexité
minimale parmi les algorithmes
de sa classe.
L'analyse au pire des cas donne
une limite supérieure de la
performance et elle garantit
qu'un algorithme ne fera
jamais moins bien que ce qu'on
a établi.
36
CALCUL DU TEMPS D’EXECUTION

38
REGLES DE CALCUL

39
EVALUATION DE T (N)
(SÉQUENCE)

• lire(a)
• Lire(b)
• S:=a+b
• Ecrire (S)

40
EVALUATION DE T (N) (SÉQUENCE)

• lire(a) → 1
• Lire(b) → 1
• S:=a+b → 2
• Ecrire (S) → 1

T(n)=1+1+2+1 = 5

41
 EVALUATION DE T(N)
(CONDITION )

Si <condition>. Tcond
Alors Traitement1. T1(n) Tcond + Max(T1(n),T2(n))
Sinon. Traitement1. T2(n)

42
 E VA L U AT I O N D E T ( N ) ( C O N D I T I O N )

• Lire(a)
• Lire(b)
• Si a< b
• alors S:=a+b
• sinon S:= 5
• S:= S+a+b

• Ecrire (S)

43
 EVALUATION DE T (N)(CONDITION )

• lire(a) → 1
• Lire(b) → 1
• Si a< b → 1
• alors S:=a+b → 2
• sinon S:= 5 1+max(2,4)= 5
• S:= S+a+b → 4

• Ecrire (S) → 1

44
 EVALUATION DE T (N)
(BOUCLE)

Tant que <condition>. Tcond* (Nbre-itéra2on + 1)

faire Tboucle = Tcond* (Nbre-itéra2on
+ 1) + T(n)* (Nbre-itéra2on)
Traitements. T(n) (Nbre-itéra2on)

Fait

Coût Boucle(d)= coût évalua2on-condi2on-sor2e(d) + coût séquence(d)

45
 EVALUATION DE T (N)(BOUCLE)

• i:=1 → 1
• Tanque i<= n
• Faire
• ecrire(i)
• i:=i+1
• fait

46
 EVALUATION DE T (N)(BOUCLE)

• i:=1 → 1
• Tanque i<= n → 1 * (n+1)
• Faire ecrire(i) → 1 * (n) T(n) = (n+1)+ 3*n
• i:=i+1. → 2 * (n)
• fait

T(n)= 1+(n+1)+(3*n) = 4n+2

47
 EVALUATION DE T (N)(SOUS
PROGRAMME)

• Sous-programme
• Pour les appels de procédures/fonc5ons (sans
récursivité́), la complexité́ est égale à la somme des
complexités de chacune de ses instruc5ons.
• Pour les procédures et fonc5ons récursives, l’analyse
donne en général lieu à la résolu5on de rela5ons de
récurrences.

48
CALCUL DE LA COMPLEXIT É
D’UN ALGORITHME

Notation de Landau

50
 CALCUL DE LA COMPLEXITÉ D’UN
ALGORITHME
☞ Quand on calcule la complexité d’un algorithme, on ne calcule
généralement pas sa complexité exacte, mais son ordre de
grandeur.

☞C’est une approximation du temps de calcul de l’algorithme.

1. Par exemple
1. T4(n)= 4n2+2n+1 on ne retiendra que l’ordre de
grandeur O(n2)

☞Pour ce faire, on a recours à la notation asymptotique O(.) ou

Notation de Landau.
1. Cette notation exprime la limite supérieure d’une fonction.51
 Vision pessimiste :
La complexité d’un algorithme est
une mesure de sa performance
asymptotique dans le pire des cas. asymptotique ?

on s’intéresse à des
Pire des cas ? données très grandes
Parmi toutes les données
x de taille n, on ne
considère que celle qui
maximise CoûtA(x)

52
 NOTATION DE LANDAU O(F(N))

Caractérise le comportement asymptotique (i.e. quand n → ∞)

T(n)=O(f(n))
Si ∃c, ∃n0 tels que ∀n>n0, T(n)≤ c×f(n)
• T(n) et en O(f(n))s’il existe un seuil à partir duquel la fonction T(.) est
toujours dominée par f(.), à une constante multiplicative fixée près.

• Exemple
• T(n)=n3 +2n2 +4n+1= O(n3) si n ≥ 1 alors f(n) ≤ 8 × n3

T(n)=O(n3) veut dire qu’il existe une constante c>0 et

une constante n0 >0 tel que n>n0, T(n) <= c.n3
53
C=8 et n0, = 1
Utilité : Le temps d’exécution est borné

Signification: Pour toutes les grandes entrées (i.e., N >= n0), on

est assuré que l’algorithme ne prend pas plus de c*f(n) étapes.

54
55
 EXEMPLE 1

• On remarque que 5n +37 <= 6.n si n >= 37

• Prouver que T1(n) =
5n+37 est en O(n) • On déduit donc que c=6 fonctionne à partir de
• But: trouver une constante n0 =37
et un seuil n0 à partir • T1(n)≤ 6.n pour tout n>=37 donc
duquel • T1(n) = O(n)
T1(n)≤ c×f(n)
Remarque: on ne demande pas d’optimiser (le plus petit c ou n0 qui fonctionne) juste il
faut donner des valeurs qui fonctionnent.

57
 EXEMPLE 2

• Prouver que T2 (n)= 4n2+2n+1 → O(n2)

• But: trouver une constante et un seuil n0 à partir • C= 5 et n0 = 3

duquel
• T2(n)≤ 5.n2 pour tout n>=3
T2(n0)≤ c×f(n0)

• T2 (n)= O(n2)
4n02+2n0 +1 <= c.n02
4n02+2n0+1<=5 n02

58
 EXEMPLE 3

• Calculer la complexité de
• T3(n) = c1.n2+c2.n T(n) <= c. n2
avec c= c1+c2 et n0=1
• T3(n)=c1.n2+c2.n<= c1.n2+c2.n2
• <= (c1+c2)n2 pour tout n>= 1

Donc T(n) est de l’ordre de O(n2 )

59
 EXEMPLE

On suppose qu'on dispose d'un algorithme dont le temps d'exécution est décrit par la fonction
T(n) = 3n2+10n+10.

L'utilisation des règles de la notation O nous permet de simplifier n :

O(T(n)) = 0(3n2 + 10n + 10)
O(T(n)) = 0(5.n2 ) pour n>=10
O(T(n)) = 0(n2 )

61
Pourn=10 nous avons :
• Temps d'exécution de 3n2: 3(10)2 / 3(10)2+10(10)+10= 73,2%

• Temps d'exécution de 10n : 10(10) / 3(10)2+10(10) +10 = 24,4%

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

Ø Le poids de 3n2 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.

62
LES RÈGLES DE LA NOTATION O SONT
LES SUIVANTES :

Les termes constants : O(c) = O(1)

On ne garde que les termes dominants

g (n) = 4n3 − 5n2 + 2n + 3

Les constantes multiplicatives sont omises :

O(cT ) = cO(T) = O(T)
O(4n3 )=O(n3 )

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(T1*T2) 63
LES RÈGLES DE LA NOTATION O SONT
LES SUIVANTES :

La complexité́ d’une conditionnelle (Si cond Alors M1 Sinon M2 Fsi) est

O(Cond) = max (cond, M1 , M2 )
(cette simplification s’effectue dans une analyse au pire des cas)

La complexité́ d’une boucle est égale à la somme sur toutes les itérations de la
complexité́ du corps de la boucle

64
 QUELQUES RÈGLES UTILES

● n.a domine n.b si a > b : par exemple, n2 domine n

● Une exponenNelle domine un polynôme : 3n domine n5 (cela
domine également 2n)
● De même, un polynôme domine un logarithme : n domine
(log n). Cela signifie également, par exemple, que n2 domine n
log n.

65
LES PRINCIPALES CLASSES DE
COMPLEXITÉ

66
LES PRINCIPALES CLASSES DE COMPLEXITÉ

67
 ALGORITHME DE CALCUL DE
COMPLEXITÉ

Pour calculer la complexité d’un algorithme :

Ø on calcule la complexité de chaque “par2e” de l’algorithme ;

Ø on combine ces complexités conformément aux règles citées;

Ø on simplifie le résultat grâce aux règles de simplifica2ons ;

ü élimina2on des constantes, et
ü conserva2on du (des) termes dominants

68
CALCUL DE LA COMPLEXITÉ

• lire(a)
• Lire(b)
• S:=a+b
• Ecrire (S)

69
 CALCUL DE LA COMPLEXITÉ

• Exemple • Exemple
• lire(a) → 1 • lire(a) → O(1)
• Lire(b) → 1 • Lire(b) → O(1)
• S:=a+b → 2 • S:=a+b → O(1)
• Ecrire (S) → 1 • Ecrire (S) → O(1)
• T(n)=1+2+1+1 = 5 • T(n)= max(O(1),O(1) ,O(1) ,O(1))=O(1)
• Tn =O(5)=O(1)

T(n) est de l’ordre O(1) Complexité constante

70
• Exemple
• lire(a) → O(1) • i:=1 → O(1)
• Lire(b) → O(1) • Tanque i<= n → O(1) * (n+1)
O(3n+n+1)
• Si a< b → O(1) • Faire ecrire(i) → O(1) * (n) =O(4n+1)=
• alors S:=a+b → O(2)=O(1) O(n)
• i:=i+1. → O(2) * (n)
sinon S:= 5 O(1) O(1)
• S:= S+a+b. O(4) =O(1)
• fait

• Ecrire (S) → O(1) T(n)= 1+(n+1)+(3*n) = 4n+2

T(n)=O(n)
T(n)=1+1+5+1=8
T(n) =O(8)=O(1)
71
EXERCICES

72
 EXERCICE 1
Algorithme Enigme? Action Nb O() Justification
Déclaration Fois
n, somme, i, nombre : entier; Moyenne : 1 1 O(1) Inst simple
réel; 2 1 O(1) Inst simple
Début 3 1 O(1) Inst simple
1. Lire(n ) 4 n+1 (n+1).O(1) Cond Boucle
(Nbiter+1) fois 1
2. somme ← 0
5 n n.O(1) Corps Boucle
3. i← 1 (Nbiter) fois 1
4. Tant que i <= n faire 6 2n 2n.O(1) Corps Boucle
5. lire( nombre) (Nbiter) fois 1
6. somme← somme + nombre 7 2n 2n.O(1) Corps Boucle
7. i ← i+1 (Nbiter) fois 1
Fin tanque 8 2 O(1) Inst simple
8. moyenne← somme/n T(n)= 6+6n O(5+6n)=O(n) Complexité
Fin linéaire 73
 EXEMPE 2
• Algorithme TRI
• 1. Pour i←1 jusqu’à m-1 faire /*BE
• 2. min_pos ← i;
3. min ← t[min_pos];
4. pour j← i+1 jusqu’à m faire /*B.I
• 5. Si (t[j] < min)
• 6. alors min_pos ← j
• 7. min ← t[min_pos]
• Finsi
• Finpour
• 8. t[min_pos] ← t[i];
• 9. t[i] ← min
• Finpour

74
Analyse et Calcul de la Complexité́ de l’algorithme TRI : Coût Tri(m)= ?

•L’ac%on 1 (évaluaion cond boucle Pour ) est exécutée m fois car (Nbre-itéra*on + 1 )*1
•Ici pas = 1 alors Nbre-itéra%on = V.F – V.I +1= (m-1) – 1 + 1 = m – 1, alors:
L’ac*on 1 est exécutée : (Nbre-itéra*on + 1 )*1= (m – 1 + 1 )*1 = m fois.

Les ac%ons 2, 3, 8, 9 (chacune a une complexité́ de l’ordre de O (1))

sont exécutées (m − 1) fois,
une fois sur chaque itéra*on de la Boucle Externe (B.E ) car: Nbre-itéra*on= V.F – V.I +1=(m-1)– 1+1=m–1.

•A la première itéra-on de la B.E ( i = 1):

• l’ac2on 4 est exécutée m fois (Nbre-itéra2on + 1 )*1= (V.F–V.I +1)++1=(m – 2 + 2 )*1 = m;
• l’ac2on 5 ( le test si) est exécutée (m − 1) fois,
• les ac2ons 6 et 7 (chacune en O(1) ) sont exécutées (m−1) fois.
75
•A la deuxième itéra-on de la B.E ( i = 2),
• l’ac2on 4 est exécutée m − 1 fois ( car: V.F–V.I +2=(m – 3 + 2 )*1 = m − 1
• et les ac2ons 5, 6 et 7 sont exécutées m-2 fois, etc. ...................................,

•A la dernière itéra2on de la B.E ( i = m − 1),

• l’ac*on 4 est exécutée 2 fois ( car: V.F–V.I +2=(m – m + 2 )*1 = 2

Donc, l’ac%on 4 est exécutée (m) + (m − 1) + (m − 2) ... + 2 = [(m-1)(m+2)/2] fois,

Rappel
(m) + (m − 1) + (m − 2) ... + 2: est une suite arithmé2que progressant de 1 dont la somme est
obtenue par: .

nbre de terme de la progression *(1er terme_Prog + dernier

terme_Prog/2=
(V.F– V.I+1)*(V.I+V.F)/2= (m-2+1)(2+m)/2

76
les actions 5, 6, 7 sont exécutés

(m − 1)+(m − 2)+...+2+1 = (V.F–V.I+1)(V.I+V.F)/2= = (m-1 – 1 -1)(m−1 +1)/2 =m(m−1)/2 fois.

D’où la complexité́ maximale ( pire des cas) est:

Coût Tri(m)= = [(m) + 4(m − 1)] O(1) + [(m-1)(m+2)/2] O(1) + 3[m(m−1)/2] )O(1)
= [m + 4m − 4 + (m2+m)/2 − 1 + (3m2−3m)/2] O(1)
= (5m − 5 + 4m2/2 − m) O(1)

= (2m2 + 4m −5) O(1)

CoûtTRI (m) ~ O(m2)

Complexité Quadratique : 2 Boucles

Imbriquées
77
78
 Action Nb Fois O() Justification
1 1 O(1) Inst simple
2 k+1 (k+1).O(1) Cond Boucle
(Nbiter+1) fois 1
3 2.k k.O(1) Corps Boucle
(Nbiter) fois 1

Coût (3k+2) O(n) Complexité linéaire

Total =3(n+2)/2+2
Nbiteration pas <> 1 =(3n/2 +5)
On pose k= nb_iter

Etape 1 i=n T(n)=O(n)

ucle
Etape 2 i= n-2=n-2*(2-1) Complexité linéaire

Une bo
Etape 3. i=n-4 =n-2*(3-1)
i= 0
Etap k. i=n-2 * (k-1)
0= n – 2*(k-1) d’où n= 2k - 2 k= (n+2)/2.
79
 Action Nb Fois O() Justification
1 1 O(1) Inst simple
2 N+1 (N+1).O(1) Cond Boucle
(Nbiter+1) fois 1
3 N N.O(1) Corps Boucle
(Nbiter) fois 1
4 (N+1)(N+1) (N2).O(1) Cond Boucle
(Nbiter+1) fois 1
5 2.N.N (N2).O(1) Corps Boucle
(Nbiter) fois 1

6 N N.O(1) Corps Boucle

(Nbiter) fois 1
Coût (1+N+1+N+N) O(N2) Complexité Quadratique
Total +(N2+
Nbiteration pas =1 2N+1+2N2)
nb_iter = Vf-Vi+1 = N =(3N2 +5N+3) 2
Im Bo
br uc
iqu les
ée
s
80
 Actio Nb Fois O() Justification
n
1 1 O(1) Inst simple
2 k+1 (k+1).O(1) Cond Boucle
(Nbiter+1) fois 1
3 2.k k.O(1) Corps Boucle
(Nbiter) fois 1

Coût (3k+2) O(log2(n)) Complexité logarithmique

Total =3(log2(N)+5)
Nbiteration pas <> 1
On pose k= nb_iter
i= N
Iteration 1 i= 1
Iteration 2 i= 2=21 N= 2(k-1) d’où log2(N)= k-1 k= log2(N) +1.
Iteration 3. i=4 =22=(3-1)

Iteration k. i=2 (k-1)

81
 Action Nb Fois O() Justification
1 1 O(1) Inst simple
2 k+1 (k+1).O(1) Cond Boucle
(Nbiter+1) fois 1
3 2.k k.O(1) Corps Boucle
(Nbiter) fois 1

Coût (3k+2)= O(log2(N)) Complexité logarithmique

Total 3(log2(N)+5
Nbiteration pas <> 1
On pose k= nb_iter

Iteration 1 i= N i= 1
Iteration 2 i= N/2=N/21
Iteration 3. i=N/4 =N/22=(3-1) 1= N/2(k-1) d’où N= 2(k-1)
K= log2(N)+1
Iteration k. i=N/2 (k-1)

82
 EXEMPLE : SOUS PROGRAMME

Algorithme principal
Procédure AA(E/S x, n : en*ers) ; Fonc*on BB (E x, n : en*ers) : en*er
Déclara*on
Déclara*on Déclara*on
un, n : en*ers
i : en*er ; i : en*er ;
Début
Début Début
6. lire(n)
1. Pour i ←1 jusqu’à n faire 3. Pour i ←1 jusqu’à n faire
7. un ←0 ;
2. x ←x + BB(i, n) 4. x ← x + i
8. AA (un, n) ;
finpour finpour
9. écrire(BB(n, n))
Fin 5. BB ← x
Fin
Fin

83
84
 Fonc*on BB (E x, n : en*ers) :
en*er
Déclara*on Les ac2ons 3 et 4 sont exécutées respec*vement n+1
i : en*er ; et n fois.
Début L’ac*on 5 est exécutée une seule fois.
3. Pour i ←1 jusqu’à n faire Coût BBn) = ( n+1 + n +1) O(1) =(2n+2)(O(1)=. O(n)
4. x ← x + i
finpour
5. BB ← x
Fin L’ac*on 2 a normalement une complexité de l’ordre
de O(1), mais il y a un appel à la fonc*on BB donc le temps
d’exécu*on de l’ac*on 2 est :
O(1) + O(n) = O(n).
Procédure AA(E/S x, n : en*ers) ;
Déclara*on Les lignes 1 et 2 se répètent, n+1 et n fois, respec*vement
i : en*er ; donc la complexité́ de la procédure AA est de l’ordre de
Début
1. Pour i ←1 jusqu’à n faire CoûtAA(n)= (n+1) O(1) + (n* O(n)) ~ O(n2).
2. x ←x + BB(i, n)
finpour CoûtAA(n)~ O(n2).
Fin

85
Algorithme principal •La complexité́ de chacune des actions 6 et 7 est de
Déclara*on
un, n : en*ers l’ordre O(1).
Début
6. lire(n) •La complexité de l’appel à AA (à la ligne 8) est de
7. un ←0 ;
8. AA (un, n) ; l’ordre de O(n2).
9. écrire(BB(n, n))
Fin •La complexité de l’action écrire (de ligne 9) égale
(à la complexité
•de l’opération de l’écriture + la complexité de
l’appel de fonction BB),
•donc : O(1) + O(n).

•
CoutAlg= O(1) + O(n2) +O(1) + O(n)= O(n2)

86
 COMPLEXITÉ D’UNE FONCTION
RECURSIVE

Complexité

T(n)= 1 si n<=1
Fonction fact(n:entier):entier O(T(n))
Debut 1+T(n-1). sinon
Si n<=1 O(1)
T(n)=1+T(n-1)
alors Fact ← 1 O(1) = 2+ T(n-2)
= 3+T(n-3)
Sinon Fact ← n*fact (n-1) = i+ T(n-i)
=n-1+T(n-(n-1)) CoutFact= O(n)
Fsi =n-1+1 Fact est de complexité linéaire
Fin; O(1) O(Tn-1) =n

87
 COMPLEXITÉ D’UNE FONCTION
RECURSIVE Complexité

T(n)= 1 si n=0
Fonction Exp(n:entier):entier O(T(n))
1+2*T(n-1). sinon
Debut
Si n=0 O(1)
T(n)=2*T(n-1)+1
alors exp ← 1 O(1) = 2 (2*T(n-2)+1)+1
= 22*T(n-2)+3
Sinon exp ← Exp(n-1)* Exp (n-1) = 22*T(n-2)+ (22 -1)
= 22 [2*T(n-3)+1]+3 = 23*T(n-3)+ 22 +3
Fsi O(1) =23*T(n-3)+ 23-1
Fin; 2*O(Tn-1) CoutExp= O(2n )
=. 2i*T(n-i)+ 2i-1 Exp est de complexité
expennentielle
= 2n*T(n-n)+ 2n-1= 2n*T(0)+ 2n -1
= 2n *1+ 2n = 2 * 2n
88
MERCI POUR VOTRE ATTENTION

89