Vous êtes sur la page 1sur 32

Université Abdelmalek Essaâdi

Ecole Nationale des Sciences Appliquées


Al Hoceima

Chapitre 3: Complexité algorithmique


Plan
I. Notion de la complexité algorithmique
II. Outils mathématiques pour la complexité
III.Calcul de la complexité

ENSAH Complexité algorithmique E.W. DADI – page : 2


I. Notion de la complexité algorithmique
1. Activité
Problème: la recherche l’existence d’un élément dans un
tableau trié.
Il est très fréquent qu’il soit nécessaire de chercher un élément
dans un tableau (exemple recherche d’un mot dans le
dictionnaire) .
Etant donné un tableau trié T de n entiers, on veut vérifier si
un entier x se trouve dans T. On va étudier 3 solutions pour ce
problème.
Solution 1 (solution naïve) : Une solution très simple consiste
à parcourir le tableau A de 1 jusqu’à n et à chaque parcours i
on test si x=T[i].

ENSAH Complexité algorithmique E.W. DADI – page : 3


…. la suite
Algorithme Recherche Séquentielle Version 1
Fonction Rech_séq_v1 (T : Tableau, n, x : Entier) : Entier
Var i : Entier;
trouve: booléen
Début
pos:=-1;
Pour i := 1 à n Faire
Si(T[i] = x) Alors pos:=i; FinSi
FinPour
Retourner(pos);
Fin
L'algorithme ci-dessus fonctionne mais à le défaut de continuer à
parcourir le tableau même quand l'élément x été trouvé. C’est-à-dire
qu’il va parcourir tout le tableau même si l’élément qu’on cherche
peut être existe au début du tableau ou avant d'être sûr qu’il ne se
trouve pas dedans.

ENSAH Complexité algorithmique E.W. DADI – page : 4


…. la suite
Solution 2 ( Recherche séquentielle version 2) : Une amélioration
de l’algorithme précédent consiste à arrêter d’avancer lorsqu'un
premier élément de tableau satisfaisant la condition T[i]=x est
trouvé.
Algorithme Recherche Séquentielle Version 2
Fonction Rech_séq_v2 (T : Tableau, n, x : Entier) : Entier
Var i : Entier;
Début
i := 1;
Tant que( i<=n) Faire
Si(T[i] = x) Alors
Retourner(i);
FinSi
i++;
FinTQ
Retourner(-1);
Fin

ENSAH Complexité algorithmique E.W. DADI – page : 5


…. la suite
Solution 3 (Recherche dichotomique): l’idée de cet algorithme est basée
sur le faite que le tableau est trié. Au lieu de comparer x avec tous les
éléments comme c’était le cas de la version séquentielle, il suffit d’exécuter
la comparaison qu’avec l’élément de milieu. L’objectif c’est à chaque tour
de vérifier est ce que x se trouve dans la partie droite/gauche du tableau.
Comme ça on élimine la moitié des éléments à chaque étape. Ainsi, la
recherche se termine beaucoup plus rapide comparé à l’algorithme
séquentielle.
Algorithme Recherche Dichotomique Version récursive
Fonction R_dicho(T: Tableau, debut, fin : Entiers) : Entier
Var m : Entier; // indice du milieu
Début
Si(debut > fin) Alors Retourner(0); FinSi
m := (debut+fin)/2;
Si(x= T[m]) Alors Retourner(m); FinSi
Si(x > T[m]) Alors Retourner(R_dicho(T, m+1, fin));
Sinon Retourner(R_dicho(T, debut, m-1));
FinSi
Fin

ENSAH Complexité algorithmique E.W. DADI – page : 6


2. Complexité d’un algorithme
Pour un problème donné, il se peut qu’il existe plusieurs algorithmes
permettant de le résoudre, mais souvent le temps de calcul pris par chacun
n’est pas le même, certaines algorithmes sont moins rapides que d’autres.
Par exemple, pour un même tableau trié, le temps d’exécution de
l’algorithme dichotomique est généralement plus rapide par rapport à
l’algorithme séquentielle, surtout si la valeur recherchée se trouve à la fin
du tableau.
La question qui se pose est : est-ce qu’il existe des outils pour comparer
théoriquement les algorithmes en termes de leur efficacité ?. La réponse est
oui.
En effet, l'efficacité d'un algorithme s’exprime en analysant sa complexité,
qui est définie comme étant la quantité de ressources (mémoire ou temps-
processeur) nécessaire pour son exécution.
C’est-à-dire on passe par le contraire on détermine combien l’algorithme
est « complexe » : (efficace # complexe)
Dans ce cours un intérêt particulier est donné à l’étude de l’efficacité d’un
algorithme en terme de temps d’exécution (Complexité temporelle).

ENSAH Complexité algorithmique E.W. DADI – page : 7


…. la suite
L’analyse de la complexité algorithmique permet de prédire l'évolution en
temps calcul nécessaire pour amener un algorithme à son terme, en
fonction de la quantité de données à traiter.
Cette complexité est indépendante de la vitesse de la machine sur laquelle
est exécuté l’algorithme. Elle donne une estimation du temps d’exécution
de l’algorithme sans tenir compte de son environnement (système
d’exploitation, compilateur, technologie, …).
Cette estimation se détermine en fonction du nombre d’opérations de base
effectuées par l’algorithme.
Parmi ses opérations, on en considère les plus importantes, celles qui sont
représentatives de l’effort de calcul. Exemples :
Problème de recherche d’un élément : la comparaison à cet élément.
Algorithme de tri : la comparaison entre les éléments du tableau, mais
aussi le déplacement des éléments.
Problème de calcul de la puissance : la multiplication

ENSAH Complexité algorithmique E.W. DADI – page : 8


II. Outils mathématiques pour la complexité
1. Temps d’exécution
Le calcul de temps d’exécution T est la somme des temps d’exécutions des
instructions exécutées par l’algorithme. Prenant l’exemple suivant :

Fonction Exemple(n :entier) Dans cet exemple, on constate que le temps


Var i, n, s: entiers ; dépendent de l’entrée n. Si n augmente T augmente.
Début Alors cette fonction de temps sera exprimée en
1. s:=0; fonction de n.
2. Pour i:=1 à n faire Supposons que les instructions élémentaires(+,-..) et
3. s:=s+i; les instructions d’affectations ont un temps constant.
FinPour Donc d’après l’algorithme on a :
4. Pour i:=1 à n faire - Instruction 1 : c1
5. Pour j:=1 à n faire - Instructions 2 et 3 : c2 * n
6. s:=s+j; - Instructions 4, 5 et 6 : c3* n*n
FinPour Le temps d’exécution est la somme des temps
FinPour d’exécutions des instructions (1,2, 3, 4, 5 ,6) :
Fin
T (n)  c1  c2 n  c3n 2

ENSAH Complexité algorithmique E.W. DADI – page : 9


2. Complexité asymptotique
Le temps d’exécution exact d’un algorithme est plus difficile à
déterminer. Mais parfois, il est possible de déterminer un temps très
approximatif (avec précision), comme nous l’avons fait pour l’exemple
précédent.
Or, une telle précision supplémentaire ne vaut généralement pas la
peine d’être calculée.
Car, pour des entrées suffisamment grandes, les effets des constantes
multiplicatives et des termes d’ordre inférieur d’un temps d’exécution
exact sont négligeables par rapport aux effets de la taille de l’entrée.
C’est pour quoi on s’intéresse à ce qu’on a appelle la complexité
asymptotique (Approximatif).
En mathématique, la comparaison asymptotique est une méthode
consistant à étudier le comportement d'une fonction au voisinage d'un
point (ou en l'infini).
Pour exprimer les changements de la complexité, on utilise
généralement trois notations asymptotique (O, , ), appelés notation
de Landau.

ENSAH Complexité algorithmique E.W. DADI – page : 10


3. Pour quoi utiliser 3 notations?
Un même algorithme peut avoir un temps d’exécution différent pour des
entrées différents. Exemple :
Fonction Primalité(a :entier) : booléen
Var i , r : entiers ;
Début
Si(a%2=0) alors Retourner faux;
Sinon
r :=racine(a)+1;
i:=3;
TantQue (i<r) Faire
Si(a%i=0) alors Retourner faux; FinSi
i:=i+2 ;
FinTq
Retourner vrai;
FinSi
Fin
Le nombre d’itérations de cette fonction n’est pas toujours le même; si a est
pair l’algorithme ne va faire aucune itération (0 itération), par contre si a
est premier il va faire +/- racine(n)/2 itérations.

ENSAH Complexité algorithmique E.W. DADI – page : 11


4. Les trois notations asymptotique
Pour exprimer l’évolution d’un algorithme en fonction de son nombre
d’opération, on utilise trois notations asymptotique suivants :
Notation grand O (Grand-O) : Une fonction g(n) est une borne supérieure
asymptotique de f(n), si et seulement :
( C  0), ( n0  0) : f(n)  Cg(n), ( n  n0).
On note alors : f(n) = O(g(n)).
Notation grand  (Grand-Omega) : Une fonction g(n) est une borne inférieure
asymptotique de f(n), si et seulement :
( C  0), ( n0  0) : f(n)  Cg(n), ( n  n0).
On note alors : f(n) = (g(n)).
Notation grand  (Grand-Theta) : Deux fonctions f(n) et g(n) ont même ordre de
grandeur asymptotique, si et seulement :
( C1  0), ( C2  0), ( n0  0) : C1g(n)  f(n)  C2g(n), ( n  n0).
On note alors : f(n) = (g(n)).

NB :
C, C1 et C2 ce sont des constants.
Les fonctions f et g représentent le temps, alors elles sont considérés positives.
Les inégalités sont considérés vraies pour les entiers assez grands et pour une constante C fixe.

ENSAH Complexité algorithmique E.W. DADI – page : 12


…. la suite
Les trois notations représentent l’ensemble de fonctions qui peuvent
borner la fonction de temps d’exécution. La notation « f(n) = O(g(n)) »
(resp (g(n)), ou (g(n))) n’est pas une égalité mathématique ce sont
des conventions d’écriture.
Les deux fonctions f et g sont considérées asymptotiquement positif.

ENSAH Complexité algorithmique E.W. DADI – page : 13


…. la suite
Exemple 1: f(n)=a*n+b, a>0, g(n)=n, on a : f(n) = O(g(n)).
En effet : comme a*n+b  a*n+b*n  (a+b)n ,  n  1, alors : ( C = a+b  0), ( n0 = 1
 0) : f(n)  Cg(n), ( n  n0).
Exemple 2: Pour f(n) = n3 + 5n2 - 7n + 18 et g(n) = n3, on a : f(n) = O(g(n)).
En effet : comme 5n2  5n3, -7n  7n3 et 18  18n3,  n  1, alors :
f(n) = n3 + 5n2 - 7n +18  n3 + 5n3 + 7n3 +18n3.
f(n)  31n3 = 31g(n).
( C = 31  0), ( n0 = 1  0) : f(n)  Cg(n), ( n  n0).
Exemple 3: Pour f(n) = 5n2log(n) + 1 et g(n) = n, on a : f(n) = (g(n)).
En effet :
5n2  5n, ( n  0).
log(n)  1, ( n  e = 2.7182883).
f(n) = 5n2log(n) + 1  5n + 1  4n, ( n  3).
f(n)  4g(n), ( n  3).
( C = 4  0), ( n0 = 3  0) : f(n)  Cg(n), ( n  n0).
Exemple 4: Pour f(n) = 3n2 + 2n + 1 et g(n) = n2, on a : f(n) = (g(n)).
En effet :
3n2 + 2n + 1  3n2 + 2n2 + n2 = 6n2 ( n  1).
3n2 + 2n + 1  2n2 ( n  0).
( C1 = 2  0), ( C2 = 6  0), ( n0 = 1  0) : C1g(n)  f(n)  C2g(n), ( n  n0).

ENSAH Complexité algorithmique E.W. DADI – page : 14


5. Propriétés des notations asymptotiques
Réflexivité :
f(n) = O(f(n)).
f(n) = (f(n)).
f(n) = (f(n)).
Transitivité :
f(n) = O(g(n)) et g(n) = O(h(n))  f(n) = O(h(n)).
f(n) = (g(n)) et g(n) = (h(n))  f(n) = (h(n)).
f(n) = (g(n)) et g(n) = (h(n))  f(n) = (h(n)).
Symétrie de  :
f(n) = (g(n))  g(n) = (f(n))
Symétrie transposée de O et  :
f(n) = O(g(n))  g(n) = (f(n))

ENSAH Complexité algorithmique E.W. DADI – page : 15


6. Formules de sommations
Soit une suite numérique (an)n0. La somme finie de cette suite est
notée : i=1,…,n(ai) = a1 + … + an où ai = f(i), pour une certaine
fonction f.
Exemples formules de sommations :
n
n(n  1) (2n  1)(n  1)n
n
n 2 (n  1) 2
 
n
i   i 2
i 
3

i 1 2 i 1 6 i 1 4
n
1  x n 1 n
i
n

 x  i
, si x  1
4
 (n  1)(2n  1)(3n 2  3n  1)
i 0 1  x i 1 30

Approximation par intégrales :


Si f est croissante, alors :
Si f est décroissante, alors :

ENSAH Complexité algorithmique E.W. DADI – page : 16


7. Fonctions classiques
Fonction logarithmique :
(∀a > 0)(∀b > 0)(∀c > 0)(∀n∈ IN), la fonction logarithme f(n) = logb(n) =
log(n)/log(b); où b est la base du logarithme.
Quelques propriétés: logc(ab)=logc(a)+logc(b), logban =nlogba,
log b a 
log a a logb n  nlogb a , a  blogb a
log b
Fonction polynomiale :
P(n) = adnd + … + a2n2 + a1n + a0.
Théorème : f(n) = adnd + … + a1n + a0 = (nd). avec la condition ad  0.
Fonction exponentielle :
f(n) = an; où a  1 (a c’est la base de l’exponentielle).
Remarques :
Une fonction polynomiale (asymp. positive) croît plus vite que
n’importe quelle fonction logarithmique.
Une fonction exponentielle quelconque avec une base > 1 croît plus
vite que n’importe quelle fonction polynomiale.

ENSAH Complexité algorithmique E.W. DADI – page : 17


8. Classes de complexité
La complexité c’est une mesure qui permet de faire différencier les
algorithmes, elle permet également de caractériser la classe de famille de
l’algorithme.
Un algorithme est dit optimal si sa complexité est minimale par rapport aux
algorithmes de sa classe.
Les algorithmes usuels peuvent être classés en un certain nombre de classes
de complexité. Les plus utilisées sont :
Constante O(1) : Accéder au premier élément d'un ensemble de données
Logarithmique O(log n) : Couper un ensemble de données en deux parties égales,
puis couper ces moitiés en deux parties égales, etc.
Linéaire O(n) : Parcourir un ensemble de données
Quasi-linéaire O(nlog n) : Couper répétitivement un ensemble de données en deux
et combiner les solutions partielles pour calculer la solution générale
Quadratique O(n2) : Parcourir un ensemble de données en utilisant deux boucles
imbriquées
Polynomiale O(np) : Parcourir un ensemble de données en utilisant p boucles
imbriquées
Exponentielle O(an) : Générer tous les sous-ensembles possibles d'un ensemble de
données

ENSAH Complexité algorithmique E.W. DADI – page : 18


…. la suite
Comparaison des classes de complexité

On considère que
Une année comporte
toute instruction
à peu prés 3.109
possède une durée
Secondes
de 10-6 secondes.
383 ans

ENSAH Complexité algorithmique E.W. DADI – page : 19


III. Calcul de la complexité
1. Généralités
Le temps d’exécution d’un algorithme pour une entrée particulière
est le nombre d’opérations élémentaires, ou « étapes », exécutées.
Une opération élémentaire est une opération qui s’effectue en temps
constant (O(1)) sur tous les calculateurs usuels. Exemples :
Comparaisons;
Affectations;
Opérations arithmétiques et logiques;
Entrée-sortie;
lecture ou écriture d’une variable simple;
accès à un tableau.
La complexité d’un algorithme est la somme des complexités de
chacune de ces instructions.

ENSAH Complexité algorithmique E.W. DADI – page : 20


2. Quelques règles
Pour les instructions conditionnelles (Si…Alors… Sinon …), on
considère la complexité maximale entre chaque branche et la condition. La
complexité de l’instruction : Si (C) alors I1 sinon I2 est max(O(f(n)),
O(f1(n)), O(f2(n))), tels que O(f(n)), O(f1(n)), O(f2(n)) sont respectivement
les complexités de la condition C, de l’instruction I1 et de l’instruction I2.
Boucle simple : O(n) si le corps de la boucle est O(1)
Double boucle : O(n2) si le corps de la boucle est O(1)
Généralement pour une boucle de type suivant :
Pour i:=0 à n Faire
I1
FinPour
Sa complexité est donnée en O(n*f1(n)), tels que f1(n) c’est la complexité
de I1.
Dans le cas de la boucle « Tant que » et au cas où la complexité de la
condition testée par cette boucle est (f(n)), la complexité est en
O(g(n)*max(f(n),f1(n))). (g(n)) complexité en nombre d’itérations,
O(f1(n)) complexité de l’instruction exécutée par la boucle.

ENSAH Complexité algorithmique E.W. DADI – page : 21


…. la suite
Exemples
Algorithme 1 Algorithme 2
Début Début
Réaliser l'opération a + b Pour i =1 à n faire
Fin Afficher i
Complexité = O(1) (constant) FinPour
Fin
Complexité = O(n) (linéaire)
Algorithme 3 Algorithme 4
Début Début
Pour i = 1 à n faire Pour i =1 à n faire
Pour j = i à n faire Pour j = i à n faire
Afficher i*j Pour k = i à n faire
FinPour Afficher i*(j+k)
FinPour FinPour
Fin FinPour
Complexité = O(n2) (quadratique) FinPour
Fin
Complexité = O(n3) (cubique)

ENSAH Complexité algorithmique E.W. DADI – page : 22


3. Complexité des algorithmes itératifs
Les étapes à suivre pour calculer le temps d’execution d’un algorithme
itératif sont :
On considère que chaque ligne de l’algorithme s’exécute en un temps
constant indépendant de la taille de données. On note ci le temps
d’exécution de l’instruction numéro i.
Chaque instruction de l’algorithme est suivi de son coût ci ainsi que du
nombre de fois où elle est exécutée.
Le temps total d’exécution d’un algorithme traitant une donnée de taille n,
noté T(n) est égal à la somme des coûts pondérés par le nombre
d’exécution de chaque instruction.
Exemple 1:
Pour i: =1 à n faire - Les instructions de cet exemple sont, i<=n, i=i+1; I1
I1 - On considère c1, c2 et c3 respectivement les couts des trois instructions.
- La boucle “Pour” s’exécute n fois et donc les 3 instructions s’exécutent
Fin aussi n fois.
- T(n)= (c1+c2 + c3 )n

ENSAH Complexité algorithmique E.W. DADI – page : 23


…. la suite
Exemple 2 : complexité d’un algorithme itératif
Prenant de calculer la complexité de l’algorithme de recherche d’un
élément dans un tableau (Rech_séq_v1)
Algorithme Rech_séq_v1 Coût Fois
Var i, pos: Entier;
Début
pos:=-1
Pour i := 1 à n Faire c1 , c2 n+1, n
Si(T[i] = x) Alors c3 n
pos:=i; c4 n
FinSi
FinPour
Retourner(pos); c5
Fin

T(n) = c1(n+1)+(c2+c3+c4)n +c5


T(n) = a*n+b
D’où T(n)= O(n)

ENSAH Complexité algorithmique E.W. DADI – page : 24


4. Complexité des algorithmes récursifs
Les étapes à suivre pour le calcul de temps d’exécution d’un
algorithme récursif sont :
Transformation de l’algorithme sous forme d’une équation de
récurrence.
Résolution de l’équation en utilisant les techniques de résolutions de
récurrence.
Il existe trois types d’équations de récurrences qui dépendent du
type d’algorithme :
a) Récurrence linéaire d’ordre 1 : La forme générale d’une équation de
récurrence simple est comme suite : T(n)=aT(n-b)+f(n)
Elle correspond aux algorithmes récursifs où la récursivité est simple,
exemple l’algorithme factorielle.
L’ équation de récurrence de la fonction factorielle est :T(n)=T(n-1)+O(1)
En utilisant la décomposition on trouve T(n)=O(n)

ENSAH Complexité algorithmique E.W. DADI – page : 25


…. la suite
b) Récurrence linéaire d’ordre 2 : La forme générale d’une équation
de récurrence linéaire est comme suite:
T(n)-a1T(n-1)- a2T(n-2)-…- akT(n-k)=cte.
A une telle équation, on associer son polynôme caractéristique :
P(x)=xk - a1xk-1 - a2xk-2 -…- ak
La résolution de ce polynôme nous donne m racines ri (avec m<=k).
La solution de l’équation de récurrence est ainsi donnée par : T(n)=c1r1n +c2r2n
+c3r3n +…+cmrmn
Exemple : utilisation de la récurrence linéaire pour calculer la complexité de la
suite récursive de Fibonacci {F(n)=F(n-1)+F(n-2), F(0)= F(1)=1}
L’équation de récurrence correspondante à F est T(n)=T(n-1)+T(n-2)+cte.
Le polynôme correspondant à l’équation de recurrence T est : P(x)= x2 – x – 1.
La résolution de cette équation donne :
n n   1  5 n 
1 5  1 5  D’où T (n)     
T (n)  a  r1n  b  r2n  a   b
 

  2  
 2   2    

ENSAH Complexité algorithmique E.W. DADI – page : 26


…. la suite
c) Récurrence de partitions : c’est une équation de la forme suivante
:  d ; si n  n0

T ( n)   n
aT ( )  f ( n)
 b
a c’est le nombre d’appels récursifs, f(n) c’est la complexité de regroupement entre les
différents appels.
Elle est utilisée pour les algorithmes où il y a la division de l’entrée à chaque
appel récursif. Exemple l’algorithme recherche dichotomique :
Fonction R_dicho(T: Tableau, debut, fin : Entier) : Entier Coût
Var m : Entier; // indice du milieu
Début
Si(debut > fin) Alors Retourner(0); FinSi c1
m := (debut+fin)/2; c2
Si(x = T[m]) Alors Retourner(m); FinSi c3
Si(x > T[m]) Alors Retourner(R_dicho(T, m+1, fin)); T(n/2)
Sinon Retourner(R_dicho(T, debut, m-1)); T(n/2)
FinSi
Fin
Soit n= debut+fin-1 la taille du tableau. L’équation de récurrence
correspondante à cet algorithme est : T(n) = c1+c2+ c3+ T(n/2) = T(n/2) +cte.

ENSAH Complexité algorithmique E.W. DADI – page : 27


…. la suite
Pour résoudre une équation de récurrence de partition on peut utiliser l’une
des méthodes suivantes :
Méthode par itérations : on explore T(n) suivant des itérations jusqu’au
cas de base.
Théorème de Master.
Méthode par itérations : pour montrer comment résoudre une
équation de récurrence de partition on va utiliser l’exemple suivant :
T(n) = T(n/2)+c
= T(n/4) + c+c
= T(n/8) + c + c+c
= T(n/ 2i)+ i * c
Quand (n/2i)= 1  log2i = log n  i =(log n / log2)  i= log2n
T (n)  T (1)  c * log 2 n
D’où T (n)  (log 2 n)

ENSAH Complexité algorithmique E.W. DADI – page : 28


…. la suite
Théorème de Master : Selon ce théorème on a :
Si f (n)  cn k , k  0, c  0
 (n k ); a  b k

T (n)  (n k log b n); si a  b k
 (n logb a ); si a  b k

Si f (n)  cn k (log b n) q , k  0, c  0
 (n k ); si a  b k et q  0
 q 1
 (n (log b n) ); si a  b et q  1
k k
T ( n)  
  ( n k
log b log b n ); si a  b k
et q  1
(n logb a ); si (a  b k et q  1)ou a  b k

ENSAH Complexité algorithmique E.W. DADI – page : 29


…. la suite
Exercice :
Utiliser la méthode par itérations puis vérifier les résultats par
le théorème de Master.:

T(n) = 2T(n/2) + n
T(n) = 9T(n/3) + n2
T(n) = 2T(n/2) + n3
Pour les trois cas vous considérez que T(1)=O(1)

ENSAH Complexité algorithmique E.W. DADI – page : 30


5. Niveaux de complexité
Soit D l'ensemble des données de taille n et T(d) le coût de
l'algorithme sur la donnée de taille d.
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. C’est une borne inférieure de la complexité de l’algorithme sur un
jeu de données de taille n.
Tmin(n)=min dєDT(d)
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 fixée, ici à n.
Tmax(n)=max dєDT(d)
Complexité en moyenne : C’est la moyenne des complexités de
l’algorithme sur des jeux de données de taille n en tenant compte de la
probabilité d’apparition de chacun des jeux de données(p(d)).
Tmoy(n)=∑ dєDp(d)T(d)

ENSAH Complexité algorithmique E.W. DADI – page : 31


…. la suite
Exemple :
Prenant de calculer la complexité de l’algorithme de recherche
séquentielle dans un tableau (la version 2 Rech_séq_v2).
Le calcul de la complexité de Rech_séq_v2 se fait selon trois
niveau :
Complexité au meilleur: le meilleur des cas est lorsque la valeur
qu’on cherche se trouve au début de tableau, dans ce cas l’algorithme
va faire qu’une seule itération d’où la complexité = O(1) .
Complexité au pire: le pire des cas est lorsque la valeur qu’on cherche
n’existe pas dans le tableau ou bien elle se trouve à la fin. Dans les
deux cas on doit parcourir le tableau de début jusqu’à la fin d’où la
complexité = O(n) .
Complexité en moyenne: la moyenne des cases est lorsque la valeur
qu’on cherche se trouve au milieu ou à une position i proche du milieu.
Le nombre de comparaison dans ce cas est i tels que à 0< i<=n, le jeu
de données est d=[1,i], T(d)=O(i). Par ailleurs, si l’on suppose que
toutes les positions de x dans le tableau sont équiprobables, la
probabilité p(d) qu’une donnée x appartienne à d est égale à 1/n. La
complexité moyenne se calcule alors de la façon suivante :
n n
i n 1
T ( n)   p ( d )  T ( d )   
i 1 i 1 n 2

ENSAH Complexité algorithmique E.W. DADI – page : 32

Vous aimerez peut-être aussi