1. CHAPITRE II:
COMPLEXITÉ
Université Saad Dahlab de Blida
Faculté des Sciences
Département d’Informatique
Licence d’Informatique
Semestre 3 (2ème année)
Algorithmique et Structures de Données
Mme AROUSSI
2016-2017
Disponible sur https://sites.google.com/a/esi.dz/s-aroussi/
2. PLAN DU CHAPITRE II
Introduction
Définitions
Type de la Complexité
Notation de de Landau
Classes de complexité
Calcul de la Complexité
2
3. 3
Le temps d’exécution d’un algorithme dépend des facteurs
suivants :
Les données du programme,
La qualité du compilateur (langage utilisé),
La machine utilisée (vitesse, mémoire, ),
La complexité de l’algorithme lui-même,
On cherche à mesurer la complexité d’un algorithme
indépendamment de la machine et du langage utilisés, c.-
à-d. uniquement en fonction de la taille des données que
l’algorithme doit traiter.
INTRODUCTION
4. 4
INTRODUCTION
EXEMPLE: CALCUL DE LA VALEUR D’UN POLYNÔME
Soit P(X) un polynôme de degré n
P(X) = anXn + an-1Xn-1 + ... + a1X + a0 ,
Où: n : entier naturel
an, an-1, ..., a1, a0 : les coefficients du polynôme qui sont
stockés dans le tableau T[0..n] d’entiers.
Ecrire la fonction Calcul_poly(T: Tableau[n+1]d’entier,
X:entier): entier.
5. 5
2ème variante
Début
Inter1
P 0
Pour 0 à n faire
DP
P P+ Inter *T[i]
Inter Inter * X
FP
Fin
1ère variante
Début
P0
Pour i 0 à n faire
DP
P P+ T[i] * Puiss (X, i)
FP
Fin
1ère Complexité :
(n+1) additions
(n+1) multiplications
(n+1) puissances
Au moins 3 variables
2ème Complexité :
(n+1) additions
2(n+1) multiplications
3 variables
INTRODUCTION
EXEMPLE: CALCUL DE LA VALEUR D’UN POLYNÔME
6. 6
3ème variante: Schéma de Horner
P(X) = anXn + an-1Xn-1 + ... +a2X2 + a1X + a0
=(anXn-1 + an-1Xn-2 + ... +a2X + a1)X + a0
= ((anXn-1 + an-1Xn-2 + ... +a2)X+ a1)X + a0
= ............
= (....(((anX + an-1)X+ an-2 )X.....)X+ ... +a2)X+ a1)X + a0
3ème variante
Début
P T[n]
Pour i n-1 à 0 faire
P P*X + T[i]
FP
Fin
3ème Complexité :
n additions
n multiplications
2 variables
INTRODUCTION
EXEMPLE: CALCUL DE LA VALEUR D’UN POLYNÔME
7. 7
Variantes Première Deuxième Troisième
Complexité
en temps
(en terme de
nombre
d’opérations)
(n+1) additions
(n+1) multiplications
(n+1) puissances
(n+1) additions
2(n+1)
multiplications
n additions
n multiplications
Complexité
en espace
mémoire
(Variables)
P, i et les variables
de la fonction
puissance appelée
(n+1) fois
P, i et Inter P, i
Nécessité d’estimer la complexité en temps et en
espace d’un algorithme avant de l’écrire et
l’implémenter
INTRODUCTION
EXEMPLE: CALCUL DE LA VALEUR D’UN POLYNÔME
8. 8
La complexité (temporelle) d’un 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. Elle est exprimée
comme une fonction de la taille du jeu de données.
Elle permet en particulier de comparer deux algorithmes traitant
le même calcul. En d’autres termes, elle permet de déterminer si
un algorithme A est meilleur qu’un algorithme B
indépendamment de la machine, du langage de programmation,
du compilateuret des détails d’implémentation.
DÉFINITION
9. 9
TYPE DE LA 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 n.
•Tmin(n) = mindDn
T(d)
Complexité en
moyenne
•C’est la moyenne des
complexités de l’algorithme
sur des jeux de données de
taille n
•Tmoy(n) = ΣdDn
T(d) / |Dn|
Complexité au
pire
• C’est le plus grand
nombre d’opérations
qu’aura à exécuter
l’algorithme sur un jeu de
données de taille n
•Tmax(n) = maxdDn
T(d)
Notations:
Dn l’ensemble des données de taille n
T(n) le nombre d’opération sur un jeu donnée de taille n
10. 10
Exemple: T(n) = O(n2) veut dire qu'il existe une
constante c > 0 et une constante n0 > 0 tel que pour tout
n > n0 T(n) <= c n2
La notation de Landau « O » est celle qui est le
plus communément utilisée pour expliquer
formellement les performances d'un algorithme.
NOTATION DE LANDAU
Cette notation exprime la limite supérieure d'une
fonction dans un facteur constant.
11. 11
Les règles de la notation O sont les suivantes :
Les termes constants : O(c) = O(1)
Les constantes multiplicatives sont omises :
O(cT ) = c O(T) = O(T)
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
O(T1)O(T2) = O(T1T2)
NOTATION DE LANDAU
12. 12
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)
Remarque:
Pour n = 10 nous avons :
Temps d'exécution de 3 n2 : 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 3 n2 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.
NOTATION DE LANDAU
13. 13
Exercice 1 : Soient T1(n) et T2(n) les temps d'exécution
de 2 fragments de programme P1 et P2 respectivement.
Montrer les règles suivantes :
Somme : Si T1(n) = O (f(n)) et T2(n) = O(g(n) ) alors
T1(n) + T2(n) = O(max (f(n), g(n) )
Produit : Si T1(n) = O( f(n) ) et T2(n) = O(g(n)) Alors
T1(n) * T2(n) = O (f(n) * g(n) )
NOTATION DE LANDAU
14. 14
CLASSES DE COMPLEXITÉ
Classe Notation O Exemple
Constante O(1) Accéderau premierélémentd'un ensemble de données
Linéaire O(n) Parcourirun ensemble de données
Logarithmique O(log(n)) Couperun ensemblede données en deux parties égales,
puis couperces moitiés en deuxparties égales,etc.
Quasi-linéaire O(n log(n)) Couperrépétitivementun ensemble de données en deux
et combinerles solutions partielles pourcalculer la
solution générale
Quadratique O(n2) Parcourirun ensemble de données en utilisantdeux
boucles imbriquées
Polynomiale O(nP) Parcourirun ensemble de données en utilisantP
boucles imbriquées
Exponentielle O(an) Générertous les sous-ensembles possibles
d'un ensemblede données
16. 16
Exercice 2 : Compléter les tableaux suivants sachant que :
Dans le tableau (a), il s'agit de calculer le nombre
d'opérations nécessaire pour exécuter l'algorithme en
fonction de sa complexité et de la taille d'instance du
problème traité.
CLASSES DE COMPLEXITÉ
17. 17
Exercice 2 : Compléter les tableaux suivants sachant que :
Dans le tableau (a), il s'agit de calculer le nombre
d'opérations nécessaire pour exécuter l'algorithme en
fonction de sa complexité et de la taille d'instance du
problème traité.
CLASSES DE COMPLEXITÉ
18. 18
Exercice 2 : Compléter les tableaux suivants sachant que :
Dans le tableau (b), il s'agit de calculer le temps
nécessaire à cela en supposant que l'on dispose d'un
ordinateur capable de réaliser 109 opérations par
seconde.
CLASSES DE COMPLEXITÉ
19. 19
Exercice 2 : Compléter les tableaux suivants sachant que :
Dans le tableau (c), on calcule la plus grande instance de
problème traitable dans le temps imparti.
CLASSES DE COMPLEXITÉ
22. 22
CALCUL DE LA COMPLEXITÉ
1. Cas d'une instruction simple (écriture, lecture, affectation ) :
Le temps d'exécution de chaque instruction simple est O(1).
2. Cas d'une suite d'instructions simples: Le temps d ’exécution
d'une séquence d'instruction est déterminée 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: O(T) = O (T1 + T2) = max(O(T1);O(T2)).
23. 23
CALCUL DE LA COMPLEXITÉ
Exemple 2:
Permutation (Var S: tableau [n] d’entier, i, j: entier)
O(T) = O (T1 + T2 + T3) = O(1)
tmpS[i] O(T1) = O(1)
S[i]S[j] O(T2) = O(1)
S[j]tmp O(T3) = O(1)
24. 24
CALCUL DE LA COMPLEXITÉ
3. Cas d'un traitement conditionnel: Le temps d'exécution d'une
instruction SI 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.
25. 25
CALCUL DE LA COMPLEXITÉ
4. 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.
Boucle Pour Boule Tant que
26. 26
CALCUL DE LA COMPLEXITÉ
Exemple 2:
Recherche séquentielle (S: tableau [n] d’entier, x: entier): booléen
i 0 O(1)
Trouve faux O(1)
Tant que ((i<n) et (non trouve)) faire Condition = O(1);
nombre d’itération = nDTQ
Si (S[i] = x) alors O(1)
Trouve vrai O(1)
i i + 1 O(1)
FTQ
Retourner trouve Q(1)
O(T) = max(O (1) + O (n *1) + O(1)) = O (n)
27. 27
Exercice 3: Considérer les algorithmes suivants avec un
temps d’exécution T(n) pour une longueur de données n.
Déterminer leur complexité et les classer par ordre croissant
Algorithme A1 T(n) = 3n+2
Algorithme A2 T(n) = 6
Algorithme A3 T(n) = 4n2+n+2
Algorithme A4 :
Pour i1 à n faire Exécuter A3
Exécuter A1
CLASSES DE COMPLEXITÉ
28. 28
Exercice 3 (suite): Considérer les algorithmes suivants
avec un temps d’exécution T(n) pour une longueur de
données n. Déterminer leur complexité et les classer par
ordre croissant
Algorithme A5 :
Exécuter A1 ; Exécuter A2 ; Exécuter A3 ;
Algorithme A6
Pour i1 à 5 faire Exécuter A1
CLASSES DE COMPLEXITÉ
29. 29
Exercice 4: Calculer la complexité au pire des algorithmes
suivants :
a) Pour i 1 à n faire Op
b) Pour i 0 à n faire Op
c) Pour i 0 à n-1 faire
Op1
Pour j0 à n-1 faire Op2
CLASSES DE COMPLEXITÉ
30. 30
Exercice 4 (suite): Calculer la complexité au pire des
algorithmes suivants :
d) Pour i 0 à n-1 faire
Op1
Pour j0 à n-1 faire
Op2
Pour k0 à n-1 faire Op3
e) Pour i 0 à n-1 faire
Op1
Pour j1 à i faire Op2
CLASSES DE COMPLEXITÉ
31. 31
Exercice 4 (suite): Calculer la complexité au pire des
algorithmes suivants :
f) Tant que (n > 0) faire
Op
nn/2
g) Pour i0 à n faire
Si i%2 = 0 alors Op1
Sinon
Pour j0 à n faire Op2
CLASSES DE COMPLEXITÉ
32. 32
Exercice 4 (suite): Calculer la complexité au pire des
algorithmes suivants :
h) Pour i0 à n faire
Op1
j 1
Répéter
Op2
jj+3
jusqu’à j >i
CLASSES DE COMPLEXITÉ
i) Pour i0 à n faire
Op1
j1
Répéter
Op2
jj*3
jusqu’à j >n
33. 33
Exercice 4 (suite): Calculer la complexité au pire des
algorithmes suivants :
k 1
Répéter
j 1
Tant que (j ≤n) faire jj*10
k k+2
jusqu’à (k ≤n)
CLASSES DE COMPLEXITÉ
34. SOURCES DE CE COURS
Frédéric Vivien, Algorithmique avancée, École Normale Supérieure de Lyon, 2002.,
pp. 93. Disponible sur http://perso.ens-lyon.fr/frederic.vivien/Enseignement/Algo-
2001-2002/Cours.pdf
Slim Msfar, Algorithmique et Complexité, 2012, pp 104. Disponible sur
http://p835.phpnet.org/testremorque/upload/catalogue/coursalgorithmi.pdf
Djamel-Eddine ZEGOUR, O-Notation, École nationale Supérieure d’Informatique,
pp 33. Disponible sur
http://www.zegour.netii.net/Site%20secondaire/Mcp/Cours%20ppt/1_o-notation.pdf
34