Complexité algorithmique

08/02/2014
1
CHAPITRE 4
Complexité des algorithmes
La O-Notation
(Partie 1)
1. Introduction
2. Efficacité en temps et en espace
3. Notation de Landau (O-Notation)
4. Classes de complexité
5. Règles de calcul de la complexité d’un
algorithme itératif
1 Chapitre 4 - O-Notation (Partie1)
Il existe souvent plusieurs algorithmes permettant de
résoudre un même problème (exemple les algorithmes de
tri). Le choix du meilleur algorithme implique une analyse
de ses performances.
En général, le critère le plus important est celui du temps
nécessaire à son exécution. Celui-ci dépend des facteurs
suivants :
• Les données entrant dans le programme,
•La qualité du code généré par le compilateur pour la
création du programme objet,
•La nature et la vitesse d’exécution des instructions du
microprocesseur utilisé pour l’exécution du programme,
• La complexité algorithmique du programme.
1. Introduction
2 Chapitre 4 - O-Notation (Partie1)
Différents algorithmes ont des coûts différents en termes
de :
* temps d’exécution (nombre d’opérations effectuées
par l’algorithme)
* taille mémoire (taille nécessaire pour stocker les
différentes structures de données pour l’exécution)
Ces deux concepts sont appelés la:
complexité en temps et en espace de l’algorithme.
2. Efficacité en temps et en espace
3 Chapitre 4 - O-Notation (Partie1)
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.
La complexité est exprimée comme une fonction de la taille
du jeu de données traitées. Ceci permet en particulier de
comparer deux algorithmes traitant le même calcul.
En d’autres termes, il permet de déterminer si un algorithme
A et meilleur qu’un algorithme B.
4
2. Efficacité en temps et en espace
Chapitre 4 - O-Notation (Partie1)

08/02/2014
2
L’étude de la complexité d’un algorithme consiste
essentiellement à évaluer la dépendance entre le temps
d’exécution et le volume de données. Les résultats
s’expriment de manière qualitative.
On cherche par exemple à savoir si la complexité croit de
manière linéaire ou polynomiale avec le volume de n
données.
Par exemple, la recherche d’un élément particulier dans un
ensemble de n éléments non triés consiste à examiner
chaque élément jusqu’à trouver celui que l’on cherche. Dans
le meilleur cas, cela prendra une seule comparaison, dans le
pire des cas, il faudra effectuer n comparaisons. En
moyenne on aura n/2 comparaisons à effectuer.
5
2. Efficacité en temps et en espace
Chapitre 4 - O-Notation (Partie1)
On distingue donc :
• 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 fixe, ici n.
• complexité au pire : C’est le plus grand nombre
d’opérations qu’aura à exécuter l’algorithme sur un jeu de
donnée de taille fixée, ici n.
• complexité en moyenne : C’est la moyenne des
complexités de l’algorithme sur des jeux de données de
taille n (en toute rigueur, il faut bien évidemment tenir
compte de la probabilité d’apparition de chacun des jeux).
6
2. Efficacité en temps et en espace
Chapitre 4 - O-Notation (Partie1)
Ce qui nous intéresse vraiment, est l’ordre de grandeur du
temps d’exécution.
Seul le terme dominant de la formule exprimant la
complexité nous importe, les termes d’ordres inférieurs
n’étant pas significatifs quand n devient grand. On ignore
également le coefficient multiplicateur constant du terme
dominant.
En général, on considère qu’un algorithme est
plus efficace qu’un autre si sa complexité dans le
pire cas a un ordre de grandeur inférieur.
7
2. Efficacité en temps et en espace
Chapitre 4 - O-Notation (Partie1)
Exemple de tri
• Problématique du tri :
- Entrée : une séquence de n nombres, α1, α2, α3,…, αn.
- Sortie : une permutation, α’1, α’2, α’3,…, α’n de la séquence
d’entrée, telle que α’1≤ α’2 ≤ α’3 ≤ … ≤ α’n
• Algorithme de tri par insertion :
Algorithme Coût Nombre d’exécutions
pour j de 2 à n faire
clé A[j]
i j-1
tant que i>0 et A[i]>clé faire
A[i+1] A[i]
i i-1
A[i+1] clé
c1
c2
c3
c4
c5
c6
c7
n
n-1
n-1
-1
-1
n-1
8
2. Efficacité en temps et en espace
Chapitre 4 - O-Notation (Partie1)

08/02/2014
3
Exemple de tri par insertion
• Le temps d’exécution total de l’algorithme est alors :
T(n) = c1n + c2(n-1) + c3(n-1) + c4
+ c5( -1) + c6( -1) + c7(n-1)
• complexité au meilleur :
Le cas le plus favorable pour l’algorithme est quand le
tableau est déjà trié. Dans ce cas tj=1 pour tout j.
T(n) = c1n + c2(n-1) + c3(n-1) + c4(n-1) + c7(n-1)
= (c1+c2+c3+c4+c7)n - (c2+c3+c4+c7)
T(n) est donc une fonction linéaire de n.
9
2. Efficacité en temps et en espace
Chapitre 4 - O-Notation (Partie1)
Exemple de tri par insertion
• complexité au pire :
le cas le plus défavorable pour l’algorithme est quand le
tableau est déjà trié dans l’ordre inverse. Dans ce cas tj = j
pour tout j.
T(n) = ( )n2+(c1+c2+c3+ +c7)n-(c2+c3+c4+c7)
T(n) peut ici être écrit sous la forme T(n) = an2 +bn+c,
a, b et c étant des constantes, et T(n) est donc une fonction
quadratique de n.
• complexité en moyenne :
tj = j/2. Si l’on reporte cette valeur dans l’équation
définissant T(n), on obtient, comme dans le pire cas, une
fonction quadratique en n.
(
10
2. Efficacité en temps et en espace
Chapitre 4 - O-Notation (Partie1)
3. Notation de Landau (O-Notation)
Quand nous calculons la complexité d’un algorithme, nous ne
calculerons généralement pas sa complexité exacte, mais son ordre
de grandeur. Pour ce faire, nous avons besoin de notations
asymptotiques.
f = O(g)
on dit que f est en O(g) (f est asymptotiquement dominée par g)
Exemple:
f(n) = 3n +1 et g(n) = n
3n+1 est en O(n)
En effet pour n0 = 2, et c = 4 on a bien pour n> n0,
l’inégalité 3n +1 <= 4n
En pratique f représente une quantité à étudier (temps, nombre
d’opérations) et g fait partie d’une échelle de fonctions simples (n,
nlog2(n), n2, etc...) destinée à informer sur le comportement
asymptotique de f.
11 Chapitre 4 - O-Notation (Partie1)
4. Classes de complexité
Les principales classes de complexité :
• Les algorithmes sub-linéaire, dont la complexité est en
général en O(log n), le top. C’est le cas de la recherche
d’un élément dans un ensemble ordonné fini de cardinal n.
• Les algorithmes linéaires : les algorithmes en O(n) et
ceux en O(n log n) sont considérés comme rapide comme
l’évaluation de la valeur d’une expression composée de n
symboles ou les algorithmes optimaux de tri.
• Les algorithmes polynomiaux en O(nk) sont considérés
comme lents pour k>2.
• Les algorithmes exponentiels (dont la complexité est
supérieure à tout polynôme en n) sont considérés comme
impraticables dès que la taille de données est supérieure à
quelques dizaines d’unités.
12 Chapitre 4 - O-Notation (Partie1)

08/02/2014
4
Comparaison des ordres de grandeurs
Du plus petit au plus grand :
O(1), O(log n), O(n log n), O(nk), O(kn), O(n!)
Propriétés
1) O(f(n)) = O(g(n)) ssi f(n) ϵ O(g(n)) et g(n) ϵ O(f(n))
2) O(f(n)) ⊂ O(g(n)) ssi f(n) ϵ O(g(n)) et g(n) ∉ O(f(n))
3) O(f(n)+g(n)) = O(max(f(n),g(n)))
4) Si lim (f(n)/g(n)) = k (k>0) Alors O(f(n)) = O(g(n))
5) Si lim (f(n)/g(n)) = 0 Alors O(f(n)) ⊂ O(g(n))
13
4. Classes de complexité
Chapitre 4 - O-Notation (Partie1)
Opérations élémentaires
C’est une opération du programme dont le temps
d’exécution est indépendant de la taille(n) de l’exemplaire
du problème à résoudre.
Généralement toutes les opérations simples (affectations,
E/S d’une unité de donnée, évaluation d’expression
simples,…) ainsi que les comparaisons (>, <,…) ont un
temps d’exécution indépendant de la taille du problème à
résoudre.
14
4. Classes de complexité
Chapitre 4 - O-Notation (Partie1)
5. Règles de calcul de la complexité
d’un algorithme itératif
Nous essayons ici de fixer des règles pour aider à
l’évaluation de la complexité en temps ou en nombre
d’opérations d’un algorithme.
Notons TA(n) le temps où le nombre d’opérations, « au pire
des cas » correspondant à la suite d’actions A, ou au calcul
de l’expression A.
Une suite d’actions est considérée ici comme une action
non élémentaire.
15 Chapitre 4 - O-Notation (Partie1)
Règle-1: Enchaînement
Soient deux suites d’actions A1 et A2, et A1+A2, la suite
«A1 suivi de A2», Alors:
TA1+A2(n) = TA1(n)+ TA2(n)
Règle-2: Conditionnelle
Soit une action A de la forme « Si C Alors A1 Sinon A2
FinSi » Alors:
TA(n) = TC(n) + Max( TA1(n), TA2(n))
En effet, dans le pire des cas, c’est toujours la plus
coûteuse des deux actions qui s’exécute.
16
5. Règles de calcul de la complexité
d’un algorithme itératif
Chapitre 4 - O-Notation (Partie1)

08/02/2014
5
Règle-3: Itération (Tant que)
Soit une action A de la forme «TantQue C Faire A1
FinTantQue»
En notant niter(n) le nombre d’itérations, on a:
TA(n) = (TC(i, n) + TA1(i, n)) + TC(niter(n) +1,n)
Cependant cette règle est trop abstraite et ce qu’il faut en
retenir est surtout le lien entre les structures répétitives et
la sommation, comme nous l’avons vu précédemment. En
particulier il est bon de lier la variable indice de la
sommation avec une variable «compteur» de la structure
répétitive lorsqu’elle existe. Il est cependant intéressant de
noter que:
17
5. Règles de calcul de la complexité
d’un algorithme itératif
Chapitre 4 - O-Notation (Partie1)
La condition C est exécutée dans le «Tant que» une fois de
plus que le « corps » A1 de la boucle.
TC n’est pas toujours une constante, mais peut dépendre de
n et du rang i de l’itération, qui est souvent lié à une
variable.
Règle-4: Fonctions et Procédures non récursives
On évalue d’abord les fonctions et procédures qui ne
contiennent pas d’appels à d’autres fonctions et
procédures, puis celles qui contiennent des appels aux
précédentes, etc…
18
5. Règles de calcul de la complexité
d’un algorithme itératif
Chapitre 4 - O-Notation (Partie1)
Remarque importante:
Lorsqu’on fait un appel, il faut en toute rigueur compter
l’appel lui-même comme une opération particulière, mais
aussi compter les opérations correspondant au passage de
l’argument.
Plus précisément, lors d’un passage par valeur, quelles
sont les opérations mises en jeu?
Pour chaque argument passé il faut évaluer l’argument (par
exemple l'addition pour factorielle(n+1), et affecter cette
valeur à une nouvelle variable (locale à la fonction).
19
5. Règles de calcul de la complexité
d’un algorithme itératif
Chapitre 4 - O-Notation (Partie1)
On néglige souvent cette dernière opération, cependant si
l’argument passé est un tableau de taille N, alors
l’affectation correspond à N affectations élémentaires, et ce
coût n’est plus négligeable. C’est en particulier une des
raisons pour lesquelles on évite souvent de passer par
valeur un tableau même si sa valeur ne doit pas être
modifiée par la procédure (ou fonction).
En effet un passage par adresse ne correspond pas à N
affectations élémentaires puisque seule l’adresse en
mémoire du tableau est fournie à la procédure lors de
l’appel.
20
5. Règles de calcul de la complexité
d’un algorithme itératif
Chapitre 4 - O-Notation (Partie1)