Université Abdelhamid Mehri-Constantine 2

Faculté NTIC
Département MI
Semestre 3
2022-2023
ASD: Algorithmique et Structures de Données
1. Pourquoi Analyser la Complexité des Algorithmes ????
Le but est:

1. Calculer le temps d'exécution théorique d'un algorithme et l’espace

mémoire nécessaire à ses données;

2. Comparer deux ou plusieurs algorithmes en terme de Complexité

et choisir le meilleur;

3. Tenter d’optimiser l’algorithme conçu en réduisant au maximum sa

Complexité.
2 . Complexité d’un algorithme
Calcul de la complexité ou l’efficacité d’un algorithme = recherche de deux quantités
importantes:
1. Q1 (Temps)= l’évolution du nombre d’instructions en fonction de la quantité
de données à traiter par l’algorithme,

2. Q 2 (Espace)= quantité de mémoire nécessaire pour effectuer les traitements de

l’algorithme.

En ASD, on s’intéresse à l’analyse de la Complexité en Temps (Temporelle) d'exécution

théorique d'un algorithme (Q1) en déterminant un ordre de grandeur, indépendamment
de l’ordinateur utilisé.
2.1. Complexité en Temps
Définition:
On appelle Complexité d’un Algorithme A pour une donnée d de taille n la durée
d’exécution de l’algorithme pour cette donnée : CoûtA(d)
Le calcul du CoûtA(d) se base sur 2 éléments:
1 Une Mesure de Taille de Donnée: définie cas par cas.
Exemple:
• Pour une matrice, c’est la dimension maximale, la somme,
ou le produit des dimensions ( selon le traitement);
• Pour un tableau, c’est le nombre d’éléments (par ex).
Ex: Traiter T avec N = 1000 elem < > traiter T avec N = 100000 elem

2 Une Unité d’Evaluation: relative au opérations jugées fondamentales au sens où le temps

d’exécution d’un algorithme est proportionnel au nombre de ces opérations.
Exemple:
Pour la recherche d’un élément X dans un tableau, l’unité pourra être la durée
d’exécution d’une instruction élémentaire (si on suppose que les instructions
élémentaires ont toutes le même temps d’exécution). On peut prendre comme unité le
coût d’une comparaison de l'élément recherché X à un élément du tableau.

En plus de la taille de donnée, la complexité varie aussi en fonction de la configuration

des données ( représentation interne) ou la localité des données.
Une MesureFonction
de TailleRecherche T :Tableau[N]
(D définie
de Donnée: d’entiers; Donnée N, X: entier ) : entier
cas par cas.
Exemple:Déclarations i : entier
Début
• Pour une matrice, c’est la dimension maximale, la somme,
oui=1 /* ou
le produit i1
des dimensions ( selon le traitement);
• Pour i<=Nc’est
un tableau,
Tantque <>T[i]d’éléments
et leXnombre faire (par ex).
Ex: Traiteri=T i+1
avec N = 1000 elem < > traiter T avec N = 100000 elem
Fintq
2 Une UnitéSi i >Nd’Evaluation:
Alors retourner (-1)auSinon
relative retourner
opérations jugées(i)fondamentales
/* ici X ==T[i]au finsi
sens
Fin d’exécution d’un algorithme est proportionnel au nombre de ces opérations.
où le temps
Exemple:
Pour la recherche d’un élément X dans un tableau, l’unité pourra être la durée
d’exécution d’une instruction élémentaire (si on suppose que les instructions
élémentaires ont toutes le même temps d’exécution). On peut prendre comme unité le
coût d’une comparaison de l'élément recherché X à un élément du tableau.

En plus de la taille de donnée, la complexité varie aussi en fonction de la configuration

des données ( représentation interne) ou la localité des données.
2.2. Notation des Coûts des Algorithmes
Pr le calcul du CoûtA(d), les notions de domination sont utilisées (notée θ(f(n)), «grand O»),
où f est une fonction de n ( n= taille des données). En algorithmique, on s’intéresse à des ordres
de grandeurs et non à des valeurs exactes. g = θ(f), veut dire: la fonction g est de l’ordre de
f. f est dominée asymptotiquement (de façon approchée) par g ( f<<g).
Les Ordres de grandeurs qu’on rencontre le plus souvent en algorithmique sont:
Log(n), n2, n3, n4, nn, 2n, Fact (n)
Un algorithme (dans le pire des cas ) est dit:
 En temps constant: si sa complexité est bornée par une constante.
 Linéaire: si sa complexité est en θ(n)).
 Sub linéaire: si sa complexité est en θ(log2(n)).
 Quadratique: si sa complexité est en θ(n2)).
 Polynômial: si sa complexité est en θ(np) pour un certain p.
 Exponentiel si sa complexité est en θ(2n).
2.3. Illustration de l’Evolution du Temps en fonction de la complexité et des données
Coût(n) de qq algorithmes (avec # comportements et # taille des données n et la durée d'une
instruction élémentaire est de l'ordre de la ns= 10-9 )
2.4. Calcul de Complexité
Calculer la complexité d’un algorithme A revient à trouver un ordre de grandeur:
CoûtA(n)= θ(….) représentant le temps d’exécution théorique de l’algorithme A en fonction de
la taille n des données d’entrée et les opérations fondamentales.

2.4.1. Instruction simple

La complexité d’une instruction d’affectation (sans appel de fonction), de lecture ou
d’écriture et test peut en général se mesurer par θ(1) (indépendant de n).

2.4.2. Séquence
La complexité d’une séquence de n instructions "i" est égale à la somme des complexités
de chaque instruction "i" qui la compose. Coût Séquence(d)=∑i=1...n coût Instruction i(d)

2.4.3. Le choix
La complexité d’une instruction conditionnelle:
Si <condition> alors séquence1 sinon Séquence2 finsi,
2.4.3. Le choix
La complexité du choix est égale à la somme de la complexité d’évaluation de la
condition et la plus grande complexité entre la séquence d’instructions exécutée si la condition
est vraie et celle exécutée si la condition est fausse.
Coût Choix(d)= coût évaluation-condition(d) + Max (coûtséquence1(d), coûtséquence2(d))

2.4.4. Répétition
La complexité d’une boucle est égale à la somme de la complexité de la séquence
d’instructions qui constitue le corps de la boucle et celle de l’évaluation de la condition de
sortie. Coût Boucle(d)= coût évaluation-condition-sortie(d) + coût séquence(d)
En detail
Coût Boucle(d)= coût condition (d) * (Nbre-itération + 1) + coût séquence(d) * Nbre-itération

2.4.5. Sous-programme
Pour les appels de procédures/fonctions (sans récursivité), la complexité est égale à la
somme des complexités de chacune de ses instructions. Pour les procédures et fonctions
récursives, l’analyse donne en général lieu à la résolution de relations de récurrences.
Exemple 1:
Calculez la complexité= Nombre d’actions exécutées par le segment S du code suivant:
Pour i ← 2 jusqu’à n pas 1 faire
somme← somme + i
fin pour
Complexité Boucle: en détail, nous avons:
Coût Boucle(d)= coût condition (d) * (Nbre-itération + 1) + coût séquence(d) * Nbre-itération

Nbre-itération d’une boucle (Pour… faire ou Tant que… faire) avec pas =1 est:
Nbre-itération=V.F–V.I+1
(valeur finale de l’indice de parcours, moins sa valeur initiale, plus 1. Pour le code S :
Nbre-itération= V.F – V.I +1 = n − 2 + 1 = n−1.
La condition de sortie ds le code S est le test (i > n) qui est de θ (1), donc:
coût évaluation-condition-sortie(d) * (Nbre-iteration + 1)= (n−1 +1 ) θ (1)= n θ (1)

Le corps de la boucle du code S est une affectation , donc de θ (1).

Ici, Nbre-itération= V.F – V.I +1 : n− 2 + 1 = n−1, d’où
 coût séquence(d) * Nbre-iteration= (n−1) θ (1), ainsi
Coût Boucle(d)= coût évaluation-cond-sortie(d) * (Nbre-itération + 1) + coût séquence(d) * Nbre-itération
Coût Boucle(d)= (n−1) θ (1) + n θ (1)= (2n−1) θ (1). Ainsi: Coût S(n) ~ θ (n). S est linéaire
Exemple 2:
Algorithme Enigme?
Déclaration n, somme, i, nombre : entier; Moyenne : réel;
Début
1. Lire(n )
2. somme ← 0
3. i← 1
4. Tant que i <= n faire
5. lire( nombre)
6. somme← somme + nombre
7. i ← i+1
Fin tanque
8. moyenne← somme/n
fin
Exemple 2: Algorithme moyenne_de_n_nombre
Chacune des actions 1, 2, et 3 sera exécutée une seule fois.
Chacune des actions 5, 6 et 7 sera exécutée n fois ( Nbre-itération=V.F–V.I+1=n -1 +1)
L’action 4 qui contrôle la boucle sera exécutée n + 1 fois (Nbre-itération + 1= n+1)
Et l’action 8 sera exécutée une seule fois:

Coûtmoyenne-de-n-nombre (n) = [1+1+1+(n+1)+n+n+n+1] θ (1) = (4n + 5) θ (1) ~ θ (n)

Coût (n) = (4n + 5) θ (1) ~ θ (n) => linéaire