Université Abdelhamid Mehri-Constantine 2

Faculté NTIC, Département MI

Semestre 3, 2023-2024

ASD: Algorithmique et Structures de Données

Chapitre 2: Notion de Complexité Algorithmique (Partie 1)

Module: Algorithmique et Structures de Université 2, Faculté NTIC, Dept MI, 2023-2024

Chapitre 2: Notion de Complexité Algorithmique Chargée de Cours : Dr. Dj-Hammoud
1. Pourquoi Analyser la Complexité des Algorithmes ????
Le but de l’analyse de la complexité des algorithmes 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)

Fondamental: 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 élem < > traiter T avec N = 100000 élem

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 Mesure de Taille
Fonction de Donnée:
Recherche (T définie casd’entiers;
:Tableau par cas. D N: entier , Input X: entier ) : entier
Exemple:
/* passage par valeur noté D (exp N), Input (exp X), Entrée ou Val, ou rien (exp T)
• Pour une matrice, c’est la dimension maximale, la somme,
ou le produit desi dimensions
Déclarations : entier ( selon le traitement);
• Pour
Débutun tableau, c’est le nombre d’éléments (par ex).
Ex: Traiter
i=1 T avec N = 1000 elem < > traiter T avec N = 100000 elem
Tantque i<=N et X <>T[i] faire
2 Une Unité d’Evaluation: relative au opérations jugées fondamentales au sens
i= i+1
où le temps d’exécution d’un algorithme est proportionnel au nombre de ces opérations.
Fintq
Exemple:
Pour Silai >N Alors retourner
recherche d’un élément (-1)XSinon
dans retourner
un tableau,(i)l’unité
/* ici pourra
X ==T[i]
être finsi
la durée
Fin
d’exécution d’une instruction élémentaire (si on suppose que les instructions élémentaires

Remarque: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), 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.
 Sub linéaire: si sa complexité est en θ(log2(n)).
 Linéaire: si sa complexité est en θ(n)).
 Quadratique: si sa complexité est en θ(n2).
 Polynômial: si sa complexité est en θ(np) pour un certain p.
n
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 # tailles 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) (au total)
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 Enigme?= 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