Complexité

Complexité algorithmique
Introduction
 Comment choisir le meilleur algorithme?
o Exemples: Trier un tableau: algorithme de tri par insertion ou de tri
rapide?…, etc
 On attend d’un algorithme qu’il résolve correctement et de
manière efficace le problème à résoudre, quelles que soient les
données à traiter.
o La correction: résout il bien le problème donné? Trouver une méthode
de résolution (exacte ou approchée) du problème.
o L’efficacité: en combien de temps et avec quelles ressources? Il est
souhaitable que nos solutions ne soient pas lentes, ne prennent pas de
l’espace mémoire considérable.
A. Naceur Algorithmique et structures de données 22
Exemple introductif
EXEMPLE: CALCUL DE LA VALEUR D’UN POLYNÔME
 P(X) un polynôme de degré n
 P(X) = anXn +an-1Xn-1 +...+ a1X +a0

o Où: n : entier naturel
o 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. 4
Exemple introductif
1ère variante 2ème variante
Début Début
P0 Inter1
Pour i de 0 à n faire P 0
P  P+ T[i] * Puiss (X, i) Pour i de 0 à n faire
Fin Pour P  P+ Inter *T[i]

Inter  Inter * X
Fin
1ère Complexité : Fin Pour
2ème Complexité :
(n+1) additions (n+1) Fin
(n+1) additions
multiplications
2(n+1)
(n+1) puissances
multiplications
Au moins 3 variables
3 variables
Exemple introductif
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 de n-1 à 0 faire 3ème Complexité :
P  P*X + T[i] n additions

n multiplications
Fin Pour
2 variables
Fin
Exemple introductif
Variantes Première Deuxième Troisième
Complexité (n+1) additions (n+1) additions n additions
en temps (en
terme de (n+1) multiplications 2(n+1) n multiplications
nombre (n+1) puissances multiplications
d’opérations)
Complexité P, i et les variables P, i et Inter P, i

en espace
mémoire de la fonction
(Variables) puissance appelée
(n+1) fois
Nécessité d’estimer la complexité en temps et en espace d’un algorithme

avant A.deNaceur
l’écrire et l’implémenter
Algorithmique et structures de données 6
Complexité temporelle
 On ne mesure pas la durée en heure, minute, seconde… cela
impliquerait d’implémenter les algorithmes qu’ on veut comparer.
 Ces mesures ne seraient pas pertinentes car le même algorithme
sera plus rapide sur une machine plus puissante.
 Au lieu de ça, on utilise des unités de temps abstraite
proportionnelles au nombre d’opérations effectuées.
 Au besoin, on pourra alors adapter ces quantités en fonction de la
machine sur laquelle l’algorithme s’exécute.

 La complexité temporelle d’un algorithme est la quantité de
temps nécessaire à son exécution complète
 Le temps d’exécution est proportionnel au nombre

d’opérations fondamentales effectuées par l’algorithme
 Opérations fondamentales : addition, soustraction, comparaison,

multiplication, …
 On cherche à mesurer la complexité d’un algorithme

indépendamment de la machine et du langage utilisés, uniquement
en fonction de la taille des données que l’algorithme doit traiter.

Type de la complexité
Complexité au Complexité en Complexité au
meilleur moyenne pire
C'est le plus petit nombre

C’est le plus grand
d'opérations qu'aura à C’est la moyenne des
nombre d’opérations
exécuter l'algorithme sur complexités de l’algorithme
qu’aura à exécuter
un jeu de données de sur des jeux de données de
l’algorithme sur un jeu de
taille n. taille n
données de taille n
•Tmin(n) = mindDnT(d) • Tmoy(n) = ΣdDn T(d) / |Dn|
•Tmax(n) = maxdDn 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 9

 De façon générale: La complexité d’un algorithme est une mesure
de sa performance asymptotique .
 asymptotique ? on s’intéresse à des données très grandes valeurs
parce que les petites valeurs ne sont pas assez informatives.
 Quand on calcule la complexité d’un algorithme, on ne calcule
généralement pas sa complexité exacte, mais son ordre de
grandeur.
 Pour ce faire, on a recours à la notation asymptotique O(.) ou
Notation de Landau.

0
Un outil mathématique:
la notation O
 Une mesure de l’ordre de grandeur d’une fonction f(n) :
trouver une fonction g(n) qui constitue une borne supérieure
de f(n) à une constante multiplicative c près et pour autant
que n soit suffisamment grand
f(n)  O(g(n)) si c > 0, n0 ≥ 1 tels que f(n) ≤ c.g(n), n ≥ n0
c.g(n)
f(n)
g(n)
n
n0
Notation de Landou
 La notation de Landau « O » est celle qui est le plus
communément utilisée pour expliquer formellement les
performances d'un algorithme.
 Cette notation exprime la limite supérieure d'une fonction dans
un facteur constant.
Exemple: T(n) = O(n2)

oIl existe une constante c > 0 et une constante n0 > 0 tel que pour tout
n > n0 T(n) <= c n2
Notations , 
  désigne une borne inférieure:
f(n)  (g(n)) si g(n)  O(f(n))
Par exemple, n3  (n2) car n2  O(n3)
  désigne une fonction asymptotiquement équivalente:
f(n)  (g(n)) si f(n)  O(g(n)) et f(n)  (g(n))
Par exemple, 400n-3  (n)

Les règles de calcul de O
 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)
 Si f(n) est un polynôme de degré m, alors f(n) est de l’ordre
du degré le plus grand : O(nm)
 log nm = O(log n) pour tout m > 0
14
A. Naceur Algorithmique et structures de données
Les règles de calcul de O
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
A. Naceurde 3 n devient encore plus
2 grandetquand
Algorithmique structures n =100, soit 96,7%
de données 15
Onpeut négliger les quantités 10n et 10. Ceci explique les règles de la notation O
Les classes de complexité
Classe Notation O Exemple
Constante O(1) Accéder au premier élément d'un ensemble de données
Linéaire O(n) Parcourir 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.
Quasi-linéaire O(n log(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

15
d'un ensemble de données
Les classes de complexité
15
Complexité des algorithmes
itératifs
Notation de Landou :
instruction simple
 Pour les instructions simples qui ne font pas appel à un sous
programme comme l'affectation et les opérations de
lecture/écriture l'instruction prend un temps d'exécution fixe
(constant) dénoté O(1) : de l’ordre de 1
 Une séquence d'instructions prend la "somme" des temps
d'exécution de chaque instruction dans la séquence.
 Si chaque instruction est en O(1) alors la somme l'est aussi.
19
Notation de Landou :
instruction simple
 Exemple : Permutation (var a: entier, var b: entier)
Instructions Taux d’exécution

x←a C1
a ←b C2
b←x C3
T =C1 +C2 +C3 =C  O(T) =O (C1 +C2 +C3) =O(C) =O(1)
20
Notation de Landou : schémas
de choix
 Pour les schémas de choix ou schémas décisionnels, on retiendra
la complexité maximale des différentes alternatives.
P(if(cond) I1 else I2) ≤ P(cond)+max(P(I1), P(I2))
O(T) =O(Tcondition) + max (O (T1), O(T2))

O(T) =max (O(Tcondition), O (T1),O(T2))
21
de choix
 Exemple : Permutation (var a: entier, var b: entier)
Instructions Taux d’exécution

Si ( a <b) C1 (Tcondition)
retourner a C2
Sinon
Retourner b C3
T =C1 +max (C2,C3)

O(T) =O (C1 +max (C2,C3)) =O(C1+C) =O(C’) =O(1)
22
itératifs
 Hypothèse: le traitement à l’intérieur de la boucle est O(1)
 Si le nombre d’itérations est constant alors la complexité est
O(1)
o Exemple: Parcours d'un intervalle constant 1..5 alors la
complexité est O(1)
 Sinon si le nombre d’itérations est fixée à N alors la complexité

est O(N)
o Exemple:
Pour i = 1..N Faire

N opérations
opérations en O(1) Algorithmique et structures de données
A. Naceur
23
FinFaire
itératifs
Instruction En général, le nombre d’itération de la

Temps d’exécution
boucle suivante: Pour i de id à if pas =
m ← T[0] C1
a est (if – id) / a + 1
Pour i allant de 1 à n-1 faire Condition: (i++; i<n) C2
Nombre d’itération: n-1
Si m>T[i] alors C3
m ← T[i] C4
Retourner (m) C5
T = C1 + n -1 (C2+ C3+C4) + C5
= max (O(1), O(n-1)) = O(n-1) = O(n) linéaire
24
itératifs
 2 boucles imbriquées (chacune à N itérations) avec des
instructions en O(1) : Complexité = O(N2)
 3 boucles imbriquées (chacune à N itérations) avec des
instructions en O(1) : Complexité = O(N3)
 M boucles imbriquées (chacune à N itérations) avec des
instructions en O(1) : Complexité = O(NM)
o Exemple:
Pour i = 1..N Faire
Pour j=1..N faire
opérations en O(1)
Fin Pour
Fin Pour
25
N opérations qui vont se faire N fois donc N*N=N2 Quadratique

Notation de Landou : boucles
multiplicatives
 Les boucles multiplicatives sont des boucles contrôlées par une
variable qui, à chaque exécution de la boucle, est divisée ou
multipliée par une constante.
 Exemple:
var  1
Tantque var <= N faire
…….
qqchose en O(1)
…….
var  2*var
FinFaire
15
Ici, la constante = 2 Algorithmique et structures de données
A. Naceur 26
multiplicatives
 Puisque var est initialisé à 1, après k itérations la variable var
sera égale à 2k (car à la sortie de la 1ère itération var=2=21 puis à
la sortie de la 2ème itération var=4=22, à la sortie de la 3eme
itération var=8=23 etc.
 Pour trouver la complexité temporelle il faut trouver k
 Le nombre d'itérations k peut être trouvé en appliquant la fonction
logarithme des deux côtés de l'égalité
27
multiplicatives
var = 2k
log2(var) = log2 (2k)
N
= k log2(2)
= k Donc k = log2(var)
 Puisque l'itération se termine quand var >= N, la complexité

de l'algorithme est en O(log2(N)) Logarithmique
28
multiplicatives
 En général, si l'on suppose que la variable de contrôle var est
multipliée par une constante Facteur, alors on peut voir
qu'après k itérations, var = Facteurk
 Dans ce cas :
var = Facteurk
logFacteur(var) = logFacteur (Facteurk)
= k logFacteur (Facteur)
=k
Donc k = logFacteur (var)
Pour var = N, k= logFacteur (N)

29
Travail à faire
Donner la complexité de l’algorithme suivant
var  N
Tantque var > 1 Faire
……..
qqchose en O(1)
……..
var  var/2
Fin tantque
30
Travail à faire (sol)
 Puisque var est initialisé à N, après k itérations la variable var
sera égale à N/2K
 Le nombre K peut être calculé comme suit: var = N/2K
log2(var) = log2 (N/2K)
= log2(N)-log2(2K)
= log2(N)-K*log2(2)
= log2(N)-K
Donc k = log2(N) - log2(var)
 Puisque l'itération se termine quand var  1 log(var) est une
constante (déjà égale à zéro) donc symplifiée la complexité de

31
l'algorithme est en O(log2(N))
Travail à faire
Fonction Recherche (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 = n
Si (S[i] = x) alors O(1)

Trouve  vrai O(1)
i i + 1 O(1)
FTQ
Retourner trouve O(1)
O(T) = max(O (1) + O (n *1) + O(1)) = O (n) linéaire26

Travail à faire
Considérer les algorithmes suivants avec un temps d’exécution T(n)
pour une longueur de données n. Déterminer leur complexité
1. Algorithme A1 T(n) = 3n+2
2. Algorithme A2 T(n) = 6
3. Algorithme A3 T(n) = 4n2+n+2
4. Algorithme A4 :
Pour i1 à n faire
Exécuter A3
27
Travail à faire
5. Algorithme A5 :
Exécuter A1 ; Exécuter A2 ; Exécuter A3 ;
6. Algorithme A6
Pour i1 à 5 faire Exécuter A1
28
Travail à faire
 Pour les fonctions de tris la mesure de complexité correspond au
nombre de comparaisons d’élément exprimé en fonction du
nombre d’élément à trier
Algo Tri par sélection
-- Précond: tab contient n valeurs, n > 1
-- Postcond: trie par sélection en ordre croissant des n valeurs de tab
pourtout i de 1 à n-1 faire
min  i
pourtout j de i+1 à n faire
si tab[j] < tab[min] alors min  j
Finsi finpour
échanger tab[i] et tab[min] 35
Finpour
Rappel
La somme des n premiers termes d’une suite géométrique de
premier terme u0 et de raison q  1 est:
n1
1 q n 1 raison nbre de termes

k 0
uk  u 0
1 q
 1er
terme 
1 raison
La somme des n+1 premiers termes d’une suite arithmétique
de premier terme u0 et de raison r est:
n
(n 1)(u0  un )
 uk 
k 0 2
nbre termes de la somme (1er terme  d er termes)

2
Le nième
A. Naceur
terme d’une suiteAlgorithmique
arithmétique de premier terme u0 et
et structures de données 36
de raison r est: un  u0  n * r
Travail à faire : solution
 La complexité temporelle = O(n2):
 À chaque étape i du tri la comparaison est exécutée par la boucle la
plus interne n-i fois.
 Il y a n-1 étapes (dans la boucle externe)
 Étape 1: n-1 comparaisons
 Etape 2: n-2 comparaisons
 …
 Etape n-1: 1 comparaison
 C’est une suite arithmétique dont le premier terme est 1, le dernier (n-
1) et la raison est de 1. Donc le nombre de comparaisons exécuté est :
n1
(n -1) (1 n 1) 2
n  n
u k  2  2
k 1 37
 La fonction (n2-n)/2 est un polynôme de degré 2 donc la
complexité temporelle est de l’ordre de O(n2)
 Cela signifie que si on multiplie par 100 le nombre

d’éléments à trier alors le temps d’exécution sera multiplié
par 10000
38
Travail à faire
Calculer la complexité temporelle de la fonction de recherche
This image c annot currently be displayed.
d’un élément dans un tableau

fonction, Appartient (donnée T : tableau d’entiers, donnée N, x : entier) :
booléen
Début
variable i : entier i  1;
Tantque ( i ≤ N et T[i] ≠ x) faire
i i+1
fin tantque
si (i>N)
retourner faux
sinon
retourner vrai
finsi
39
fin A. Naceur Algorithmique et structures de données
 Complexité :
 Il y a au plus N itérations (N est la taille des données)
 La complexité est de N au pire des cas: O(N)
40
Travail à faire
 Complexité temporelle de la recherche dichotomique
 Recherche d’un élément dans un tableau de n éléments triés
 Principe: diviser l’intervalle en 2 et tester sur l’élément du milieu si
ok arrêt sinon recherche à droite ou à gauche
41
Fonction RechercheDicho(Tab: tableau Entier, N : Entier, elem :
Entier): Entier
Début, Milieu, Fin : Entier Début
Début  1 O(1)
Fin  N O(1)
Milieu € (Début + Fin) Div 2 O(1)
Tantque Début<=Fin et Tab[Milieu] ≠ elem Faire O(1)
Si Tab[milieu] < elem Alors
Début  Milieu +1 O(1)
Sinon Fin  Milieu – 1
Fin si
Milieu  (Début + Fin) Div 2 O(1)
Fin TQ
Si Début > Fin Alors
RechercheDicho
A. Naceur  -1 Sinon RecherDicho
Algorithmique  Milieu
et structures de données O(1)
FinSi Fin
 Supposons que N=2p (cad c’est un nombre qui s’écrit en puissance 2) alors
Numéro du test Nombre d’éléments dans l’intervalle
1er N
2 N/2
3 N/22
… …
p N/2p-1
p+1 N/2p arrêt car il reste un élément puisque N=2p donc N/2p = 2p / 2p =1
 Donc le nombre maximum de test (pire) est p+1

 Or log2 (2p) = log2 (N)
 p* log2 (2) = log2 (N)
 p* 1 = log2 (N)
 p = log2 (N)
 p +1= log2 (N) + 1
 Cad au pire on a log2 (N) + 1 tests
La complexité au pire est O(log
A. Naceur 2 (N))et structures de données
Algorithmique 43
Complexité des algorithmes
récursifs
Résumé
 L’efficacité d’un programme se caractérise par son temps d’exécution et
son espace mémoire
 Ces notions dépendent de beaucoup de facteurs (CPU, charge du
réseau, qualité de l’algo, langage de programmation, etc.)
 La complexité asymptotique (temporelle et spatiale) permet d’analyser la
qualité des algorithmes, indépendamment des autres facteurs et sans
devoir les implémenter
 Il suffit de compter le nombre d’opérations primitives (ignorer des
grandeurs qui ne dépendent pas de la taille du problème)
 La complexité spatiale est déterminée par un raisonnement analogue
 Certains problèmes sont insolubles pour des raisons fondamentales, par
exemple les problèmes NP-complets, pour lesquels les meilleurs
algorithmes connus sont exponentiels

Résumé
 Entraînez-vous à calculer la complexité des algorithmes que
vous avez produits pour dans les autres chapitres du cours :
tableaux, listes chaînées et arbres

Complexité

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Complexité

Transféré par

Droits d'auteur :

Formats disponibles

Complexité algorithmique

 P(X) un polynôme de degré n

 P(X) = anXn +an-1Xn-1 +...+ a1X +a0

Ecrire la fonction Calcul_poly (T: Tableau[n+1] d’entier,

P  P+ T[i] * Puiss (X, i) Pour i de 0 à n faire

Fin Pour P  P+ Inter *T[i]

= (....(((anX + an-1)X+ an-2 )X.....)X+ ... +a2)X+ a1)X + + a0

P  P*X + T[i] n additions

Complexité P, i et les variables P, i et Inter P, i

Nécessité d’estimer la complexité en temps et en espace d’un algorithme

A. Naceur Algorithmique et structures de données 77

 Le temps d’exécution est proportionnel au nombre

 Opérations fondamentales : addition, soustraction, comparaison,

 On cherche à mesurer la complexité d’un algorithme

A. Naceur Algorithmique et structures de données 88

C'est le plus petit nombre

 Dn l’ensemble des données de taille n

 T(n) le nombre d’opération sur un jeu donnée de taille n 9

A. Naceur Algorithmique et structures de données 101

Exemple: T(n) = O(n2)

f(n)  (g(n)) si g(n)  O(f(n))

Par exemple, n3  (n2) car n2  O(n3)

  désigne une fonction asymptotiquement équivalente:

f(n)  (g(n)) si f(n)  O(g(n)) et f(n)  (g(n))

Par exemple, 400n-3  (n)

 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%

Linéaire O(n) Parcourir un ensemble de données

Logarithmique O(log(n)) Couper un ensemble de données en deux parties égales, puis

Quasi-linéaire O(n log(n)) Couper répétitivement un ensemble de données en deux et

Quadratique O(n2) Parcourir un ensemble de données en utilisant deux boucles

Polynomiale O(nP) Parcourir un ensemble de données en utilisant P boucles

Exponentielle O(an) Générer tous les sous-ensembles possibles

Instructions Taux d’exécution

T =C1 +C2 +C3 =C  O(T) =O (C1 +C2 +C3) =O(C) =O(1)

P(if(cond) I1 else I2) ≤ P(cond)+max(P(I1), P(I2))

O(T) =O(Tcondition) + max (O (T1), O(T2))

Instructions Taux d’exécution

T =C1 +max (C2,C3)

 Sinon si le nombre d’itérations est fixée à N alors la complexité

Pour i = 1..N Faire

Instruction En général, le nombre d’itération de la

N opérations qui vont se faire N fois donc N*N=N2 Quadratique

 Puisque l'itération se termine quand var >= N, la complexité

Pour var = N, k= logFacteur (N)

constante (déjà égale à zéro) donc symplifiée la complexité de

Si (S[i] = x) alors O(1)

O(T) = max(O (1) + O (n *1) + O(1)) = O (n) linéaire26

3. Algorithme A3 T(n) = 4n2+n+2

Pour i1 à n faire

Exécuter A1 ; Exécuter A2 ; Exécuter A3 ;

Pour i1 à 5 faire Exécuter A1

 Etape 2: n-2 comparaisons

 Etape n-1: 1 comparaison

 Cela signifie que si on multiplie par 100 le nombre

d’un élément dans un tableau

 Donc le nombre maximum de test (pire) est p+1

A. Naceur Algorithmique et structures de données 45

A. Naceur Algorithmique et structures de données 46

Vous aimerez peut-être aussi