Conception, Analyse et Complexité des algorithmique Chapitre 1

Chapitre 1 Les bases de l’analyse algorithmique

1. Notion d'algorithme
La résolution informatique d'un problème donné passe par un algorithme qui est
implémenté par un langage de programmation.

Exemples
- Calcul de puissance :
Entrée : deux entiers naturels a,n
Sortie : an
- Algorithme de tri :
Entrée : un tableau de n entiers tab = [a0, a1,……., an-1]
Sortie : un tableau de n entiers tab = [b0, b1,…., bn-1] t..q.. b0 <= b1 <=….. <= bn-1

2. Complexité des algorithmes

Un algorithme est dit correct si, pour chaque donnée en entrée, il doit fournir la bonne
sortie. Dans ce cas, on dit que l'algorithme (correct) résout le problème donné.
Les algorithmes corrects diffèrent entre eux en termes d'efficacité. Ces différences peuvent
être bien plus importantes que celles dues au matériel et au logiciel.
La notion de complexité signifie deux concepts :

- La complexité des problèmes : C'est l'étude qui permet la classification des

problèmes en fonction des performances des meilleurs algorithmes connus qui les
résolvent.
- la complexité des algorithmes : C'est l'étude de l'efficacité comparée des
algorithmes.
En effet, la complexité introduit la notion de coût et montre qu'il ne suffit pas de trouver une
méthode correcte pour résoudre un problème, il faut aussi que cette méthode soit efficace.
L'efficacité est mesurée par les ressources (le temps et l'espace mémoire) nécessaires à un
algorithme pour résoudre un problème.
- le temps d'exécution : la complexité temporelle
- l'espace mémoire requis : la complexité spatiale

3. Analyse d’algorithme
Analyser un algorithme est une opération qui consiste à prévoir les ressources nécessaires
(mémoire, temps de calcul) au programme qui implémente cet algorithme.
Pour pouvoir analyser un algorithme, il faut avoir un modèle de la technologie qui sera
employé. En algorithmique, les algorithmes sont analysés selon les calculs dans un modèle
générique de machine à accès aléatoires (RAM=Random Access Machine), à processeur
unique. L’Analyse des algorithmes est équivalente à l’étude de la complexité des
algorithmes.

3.1. Le temps d'exécution

Le temps d'exécution (calcul) d'un algorithme sur une entrée particulière est le nombre
d'opérations élémentaire (affectations, comparaisons, opérations arithmétiques), exécutées.
L'idée est d'évaluer le temps de calcul en fonction d'une grandeur n représentant la taille des
données.

1
 Conception, Analyse et Complexité des algorithmique Chapitre 1

3.2. Taille des données

On se contente souvent d'estimer l'influence de la taille des données sur la taille des
ressources nécessaires. Ainsi, La taille des données dépend du problème étudié
On appelle les entrées ou les instances la taille des données nécessaires à un algorithme
pour résoudre un problème donné. La taille n va dépendre du codage de ces entrées
Exemple : en binaire, il faut |log2(n) |+ 1 bits pour coder l'entier n.

En pratique, on choisit comme taille la ou les dimensions les plus significatives.

Exemple :
- des matrices m x n : max(m; n), m:n, m + n
- des listes, tableaux, fichiers : nombre de cases, d'éléments
- des chaînes de caractères : leur longueur

4. Evaluation du temps de calcul

Soit
- P : un problème et M : une méthode pour résoudre le problème P
- L’algorithme A: description de M dans un langage donnée (algorithmique, C/C++,
Java, ...)

L’objectif est d’évaluer le temps de calcul de A pour P pour pouvoir comparer A avec un
autre algorithme A’. L'évaluation dépend de la taille du problème, elle doit être
indépendante de l’environnement (machine utilisée .système, compilateur, . . .)

La complexité d'un algorithme ou l'évaluation du temps de calcul d'un algorithme est une
mesure de coût exprimée en fonction de la taille n des données :
T(n)=nombre d'opérations élémentaires

On distingue trois sortes de complexités :

La complexité dans le pire des cas : calcul du coût dans le pire des cas,
( ) { ( )}
La complexité en moyenne : calcul du coût pour chaque donnée possible puis on
divise la somme de ces coûts par le nombre de données différentes,
( ) ∑ { ( )} n)
La complexité dans le meilleur des cas : Calcul du coût en se plaçant dans le meilleur
des cas.
( ) { ( )}

Remarque : En analyse de complexité, on étudie souvent le pire des cas ce qui donne une
borne supérieure de la complexité de l'algorithme.

Evaluation de T(n)
- Séquence (sommes des coûts)

( )
{ ⇒ ( ) ( ) ( ) ( )
( )

2
 Conception, Analyse et Complexité des algorithmique Chapitre 1

-Embranchement (Max des coûts)

( ) ( )
{ ( ) ⇒ ( ) ( ( ) ( ))

-Boucle (Somme des coûts de chaque passage)

( )
( ) ⇒ ( ) ∑ ( )
{

K = nombre de répétition du traitement ( )

5. Notation asymptotique
En pratique une analyse précise d'un algorithme même dans le pire des cas est presque
impossible (sauf pour un algorithme simple). La solution est d'établir une approximation
asymptotique du temps de calcul de l'algorithme. Ainsi, on compare l'efficacité
asymptotique des algorithmes.

5.1. Notation de Landau  -Notation

Soient T(n) la fonction de complexité et f une fonction de N dans R.
On dit que f(n) est une borne approchée asymptotique pour T(n) et l'on écrit T(n)  (f(n))
s'il existe deux constantes strictement positives c1 et c2 telles que, pour n assez grand, on a :

( ) ( ) ( )

Ceci revient à dire que T(n) est égale à f(n) à un facteur constant près.
Pour indiquer que T(n)   (f(n)), on écrit T(n) =  (f(n))

5.2. Notation de Landau O–Notation

Soient T(n) la fonction de complexité et f une fonction de N dans R.
On dit que f(n) est une borne supérieure asymptotique pour T(n) et l'on écrit T(n)  (f(n)) s'il
existe une constante strictement positive c telle que pour n assez grand (n ) on ait

( ) ( )

3
 Conception, Analyse et Complexité des algorithmique Chapitre 1

Ceci revient à dire que T(n) est inférieure à f(n) à une constante près et pour n assez grand.
Pour indiquer que T(n)  O (f(n)), on écrit T(n) = O (f(n)).

5.3. Notation landau -Notation

Soient T(n) la fonction de complexité et f une fonction de N dans R.
On dit que f(n) est une borne inférieure asymptotique pour T(n) et l'on écrit T(n)  (f(n))
s'il existe une constante strictement positive c telle que pour n assez grand on ait

( ) ( )
Ceci revient à dire que T(n) est supérieure à f(n) à une constante près et pour n assez grand.
Pour indiquer que T(n)   (f(n)), on écrit T(n) =  (f(n)).

6. Classes de complexité
Un algorithme A résout un problème P en temps O(f(n)) si pour toute instance de taille n,
l'algorithme retourne une solution correcte avec un coût O(f(n)).
La nature de la fonction f(n) définie la classe de complexité ou le niveau de complexité de
l'algorithme A.
Lors de l'analyse de complexité, on essaie de se ramener aux classes suivantes :

- Complexité constante : Coût : O(1)

Exemple : addition, affectation...
- Complexité logarithmique : Coût : O(log(n))
Exemple : recherche dichotomique dans un tableau trié A[1..n]
- Complexité linéaire : Coût : O(n)
Exemple : calcul du produit scalaire de deux vecteurs de Rn
- Complexité linéaire - logarithmique : Coût : O(nlog(n))
Exemple : Tri par fusion
- Complexité polynômial : Coût : O(nk), k > 1, pour k = 2, on parle de la Complexité
quadratique
Exemple : Multiplication de deux matrices carrées d'ordre n : O(n3)
- Complexité exponentielle : Coût : O(an) avec a > 1
Exemple : Tours de Hanoi.

On peut établir une hiérarchie entre les classes de complexité du plus petit au plus grand :
O(1)  O(log(n))  O(n)  O(nlog(n))  O(n2)  O(nk)  O(an) , avec k > 2, a > 1

4
 Conception, Analyse et Complexité des algorithmique Chapitre 1

- Comparaison des temps d’exécution selon la taille des données

T(n) n =10 n = 20 n =30 n =40 n =50 n =60

n 1 s 1.3 s 1.5 s 1.6 s 1.7 s 1.8 s
Log 10 s 20 s 30 s 40 s 50 s 60 s
n log n 10 s 26 s 44 s 64 s 85 s 107 s
n2 100 s 400 s 900 s 1.6 ms 2.5 ms 3.6 ms
n3 1 ms 8 ms 27 ms 64 ms 125 ms 216 ms
n5 0.1 ms 3s 24 mn 1.7 mn 5 mn 13 mn
2n 1 ms 1s 18 mn 13 jours 36 ans 366 siècles
3n 60 ms 1 heure 6 ans 3900 siècles 2 x108 1.3 x 1013
Siècles siècles

Exemples
- Quelques fonctions
T(n) = n3 + 2 n2 + 4 n + 2 = O(n3) (si n ≥ 1 alors f(n) ≤ 8 × n3)
T(n) = n log n + 12 n + 888 = O(n log n)
T(n) = 1000 n10 − n7 + 12 n4 + 2n/1000 = O(2n)

- Permutation
fonction permutation (S, i, j)
tmp  S[i],
S[i]  S[j],
S[j]  tmp,
renvoyer S
coût total T(n) = 4 = O(1)

- Recherche séquentielle
fonction recherche (x, S, n)
i  1,
tant que ((i < n) et (S[i] ≠ x)) faire
i  i + 1,
renvoyer (S[i] = x)

Pire des cas : n fois la boucle ( ) ∑ ( )