Vous êtes sur la page 1sur 15

COMPLEXITE ALGORITHMIQUE

Dr Hamidou TOGO
FST/USTTB
Complexité des Algos
• Évaluation du nombre d’opérations élémentaires en fonction:
• De la taille des données,
• De la nature des données.
• Notations:
• n : taille des données
• T(n) : nombre d’opérations élémentaires  coût
• NB: une opération élémentaire est une opération dont le temps
d’exécution est indépendant de n : +, *, /, lecture, écriture,
incrémentation, …
Evalution de T(n)
• Séquence:
Instruction 1 T1(n)
.
.
T(n) = T1(n) + … + Ti(n)
.
Instruction i Ti(n)
Evalution de T(n)
• Condition :

si < condition > alors T0


Instruction1 T1(n) T(n) = T0+ max{T1(n), T2(n)}
sinon
Instruction2 T2(n)
Evalution de T(n)
• Boucle :

tant que < condition > faire T0


Instruction Ti(n)
fin Tant que
T(n) =෌ 𝑇0 + 𝑇𝑖 𝑛

Pour i allant 1 à k
instruction Ti(n)
Fin Pour T(n) =෌ 𝑇𝑖 𝑛
Exemple 1
• Calculer le coût de l’algo permettant de calculer la factorielle d’un
entier n
Exple 2: calculer le coût des programmes
somme1 { somme2 {
s=0;
s=0;
for(int i=1; i<=n+1, i++){
for(int i=1; i<=n+1, i++){
for(int j=1, j<=n+1; j++) {
s=s+i; s=s+i;
} }
return s; }
} return s;
}
Estimation asymptotique
• A la vue des calculs précédents, on comprend bien que donner un
résultat précis va vite devenir impossible et inutile.
• Comment par exemple ne pas oublier une opération élémentaire
dans un algorithme de quelques centaines de ligne ?
• On va donc plutôt s’intéresser à une complexité asymptotique,
qui sera une approximation du nombre d’opérations élémentaires.
• Cela nous permettra d’avoir des calculs gérables sans pour autant
perdre en pertinence.
Estimation asymptotique
• Soit T(n) une fonction qui désigne le temps de calcul d'un algorithme A.
• On dit que T est asymptotiquement majorée (ou dominée) par f et on écrit
𝑇 = 𝑂 ( 𝑓 ) quand il existe une constante c, c>0, telle que pour un n
assez grand, on a : T(𝑛) ≤ 𝑐 . 𝑓(𝑛)
• On dit alors que la complexité de A est 𝑶 ( 𝒇 )
• On définit symétriquement la minoration de T par f T = Ω ( 𝑓 ).
• On dit que T est du même ordre de grandeur que f et on écrit T =
𝜃 ( 𝑓 ) quand T = 𝑂 ( 𝑓 ) et 𝑓 = 𝑂 ( 𝑇 )

9
Exemple 1 :
• si T(n) = 3n + 6 alors T(n) = O(n)
Démonstration :
En effet, pour n >= 2, on a 3n + 6 <= 9n ; la quantité 3n + 6 est donc
bornée, a partir d'un certain rang, par le produit de n et d'une constante.

Exemple 2 :
• si T(n) = n2 + 3n alors T(n) = O(n2)
Pour n >= 3, on a n2 + 3n <= 2n2 ; la quantité n2 + 3n est donc bornée, à
partir d'un certain rang, par le produit de n2 et d'une constante.
Règle générale
Pour calculer la complexité d’un programme
• On calcule la complexité de chaque partie du programme;
• On combine ces complexités conformément aux règles qu’on vient de
voir ;
• On simplifie le résultat grâce aux règles de simplifications svtes:
• On remplace les constantes multiplicatives par 1
• On annule les constantes additives
• On conserve le terme dominant
• Ex: T(n)=5n3-6n2+4  T(n)=O(n3)
Exple:
• Calculer la complexité de l’Algo Factorielle

• Calculer la complexité de l’algo permettant de déterminer la primalité


d’un nombre
Classes de complexité
• Les complexités algorithmiques que nous allons calculer vont
dorénavant être exprimées comme des grand O ou grand
Théta de fonctions de références. Cela va nous permettre de
les classer.
• Des algorithmes appartenant à une même classe seront alors
considérés comme de complexité équivalente. Cela signifiera que l'on
considèrera qu'ils ont la même efficacité.
Comparatif: complexité et temps d’exécution

14
Type d’étude de complexité
• La complexité dans le pire des cas
• Estime le temps maximum possible (par exemple, tri par insertion d’un tableau déjà trié
dans l’ordre inverse)
• C’est donc 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.
• La complexité moyenne
• Évalue, à partir d'une répartition probabiliste des tailles de données, le temps moyen que
l'on peut attendre de l'évaluation d'un algorithme sur une donnée d'une certaine taille
• C’est donc la moyenne des complexités de l’algorithme sur des jeux de données de taille
n
• La complexité dans le meilleur des cas
• Estime le temps minimum possible (par exemple, tri par insertion d’un tableau déjà trié)
• C’est donc 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.
15

Vous aimerez peut-être aussi