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 2)

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
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.
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).

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)

Choix
La complexité d’une instruction conditionnelle:
Si <condition> alors Séquence1 sinon Séquence2 finsi,
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))

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

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 3:
Soit le code suivant d’un algorithme de Tri (dit: «Tri par Sélection »). Trouvez le nombre
d’actions exécutées et la complexité de cet algorithme?

Juste le code pas de données

Algorithme TRI
1. Pour i←1 jusqu’à m-1 faire /*B.E Avant de commencer le calcul de
2. min-Pos ← i; la complexité, lisez et analysez
3. min ← t[min-pos]; l’algorithme pr comprendre son
4. pour j← i+1 jusqu’à m faire /*B.I fonctionnement et trouver le
5. Si (t[j] < min) pire des cas
6. alors debut min-pos ← j
7. min ← t[min-pos] fin
Finsi
Finpour Ici on affecte le minimum à la position: i, donc à 1, 2….
8. t[min-pos] ← t[i]; et t[i] occupera l’anciènne pos du min. une permutation pr
9. t[i] ← min placer le min à sa bonne place
Finpour
Analyse et Calcul de la Complexité de l’algorithme TRI : Coût Tri(m)= ?
Coût Boucle(d)= coût condition-sortie(d) * (Nbre-itération + 1) + coût séquence(d) * Nbre-itération
(Voir Vidéo 5 et 6)
• L’action 1 (évaluaion cond boucle Pour ) est exécutée m fois car (Nbre-itération + 1 )*1
• Ici pas = 1 alors Nbre-itération= V.F – V.I +1= (m-1) – 1 + 1 = m – 1, alors:
• L’action 1 est exécutée : (Nbre-itération + 1 )*1= (m – 1 + 1 )*1 = m fois.
Les actions 2, 3, 8, 9 (chacune a une complexité de θ(1))
sont exécutées (m − 1) fois, une fois sur chaque itération de la Boucle Externe (B.E ) car: Nbre-
itération= V.F – V.I +1= (m-1) – 1 + 1 = m – 1.
• A la première itération de la B.E (i = 1):
• l’action 4 est exécutée m fois (Nbre-itération + 1 )*1= V.F–V.I +2=(m – 2 + 2 )*1 = m;
• l’action 5 (le test si) est exécutée m − 1 fois,
• et en supposant le pire des cas où les éléments de la collection sont dans un ordre
descendant, les actions 6 et 7 (chacune en θ(1) ) sont exécutées (m−1) fois.
• A la deuxième itération de la B.E ( i = 2),
• l’action 4 est exécutée m − 1 fois ( car: V.F–V.I +2=(m – 3 + 2 )*1 = m − 1
• et les actions 5, 6 et 7 sont exécutées m-2 fois, etc.
……………………………..,
• A la dernière itération de la B.E ( i = m − 1),
• l’action 4 est exécutée 2 fois (car: V.F–V.I +2= (m – m + 2 )*1 = 2

Donc, l’action 4 est exécutée (m) + (m − 1) + (m − 2) ... + 2 = [(m-1)(m+2)/2] fois, car:

(m) + (m − 1) + (m − 2) ... + 2: est une suite arithmétique progressant de 1 dont la
somme est obtenue par: nbre de terme (1er terme + dernier terme)/2=
(V.F–V.I+1)(V.I+V.F)/2= (m-2+1)(2+m)/2 . Donc ( au total), l’action 4 est exécutée:
(m) + (m−1) + (m−2) ... + 2= (m-2+1)(2+m)/2= (m-1)(m+2)/2
et les actions 5, 6, 7 sont exécutés (m − 1)+(m − 2)+...+2+1 = (V.F–V.I+1)(V.I+V.F)/2= =
(m-1 – 1 -1)(m−1 +1)/2 =m(m−1)/2 fois.
D’où la complexité maximale ( pire des cas) est:

Coût Tri(m)= = [(m) + 4(m − 1)] θ(1) + [(m-1)(m+2)/2] θ(1) + 3[m(m−1)/2] θ(1)
= [m + 4m − 4 + (m2+m)/2 − 1 + (3m2−3m)/2] θ(1)
= (5m − 5 + 4m2/2 − m) θ(1) Algorithme TRI
1. Pour i←1 jusqu’à m-1 faire
= (2m2 + 4m −5) θ(1) 2. min-pos ← i;
CoûtTRI (m) ~ θ (m2) 3. min ← t[min-pos];
4. pour j← i+1 jusqu’à m faire
5. Si (t[j] < min) alors
(2 boucles imbriquées, pas =1) 6. min-pos ← j
d’où Tri quadratique 7. min ← t[min-pos]
Finsi
Finpour
8. t[min-pos] ← t[i];
9. t[i] ← min
Finpour
Exemple 4:
Algo. A Analysez la complexité des algorithmes suivants en déterminant
… l’ordre du temps de calcul, pour chacun d’eux.
Début
1. i = N Algo. B
2. tant que i >= 0 Faire …
3. i = i – 2 Début Algo. D
fintq 1. i=1 …
Fin 2. tant que i <= N faire Début
3. J=1 1. i = N
Algo. C
4. tant que J <= N faire
… 2. tant que i >= 1 faire
Début 5. J=J+1
ftq 3.i = i / 2
1. i =1
2. tant que i <= N faire 6. i=i+1 ftq
3. i = i*2 Ftq Fin
ftq
Fin
L’ordre de grandeur en temps de ces 4 algorithmes est illustré dans le tableau ci-dessous, avec:
1. Rappel: boucle avec pas =1, Nbre-itération= (V.F–V.I + 1)
2. Maintenant boucle avec pas < >1, nous posons K= Nbre-itération et il faut
raisonner pour trouver K.
Actions Algo.A Algo.B Algo.C Algo.D
1 ϴ(1) ϴ(1) ϴ(1) ϴ(1)
2 (K+1)ϴ(1) (N-1+1+1) ϴ(1)=(N+1)ϴ(1) (K+1)ϴ(1) (K+1)ϴ(1)
3 K ϴ(1) (N-1+1) ϴ(1)= Nϴ (1) Kϴ (1) Kϴ(1)
N (N-
4 - - -
1+1+1)ϴ(1)=N(N+1)ϴ(1)
5 - (N) (N)ϴ(1)= N2ϴ (1) - -
6 - Nϴ(1) - -
CoûtAlgo.A(N)=
(1+K+1+K)ϴ(1) CoûtAlgo.D(N) ≈
total
=(N+4)ϴ(1) CoûtAlgo.B(N) ≈ ϴ (N2) CoûtAlgo.C(N)≈ϴ (logN)
ϴ (logN)
≈ϴ(N)
Calcul du Nbre-itération: K pour L’ Algorithme A
Algo. A Algo. A
…
à l’étape 1 (iteration 1) , I=N Début
à l’étape 2, I=N-2 1. i = N
2. tant que i >= 0 Faire
à l’étape 3, I= (N-2 ) –2= N-4 = N-2*2= N-2*(3-1) 3. i = i – 2
à l’étape 4, I= ((N-4 ) –2)= N - 6 = N-2*3= N-2*(4-1) fintq
Fin
à l’étape K, I= N-2*(K-1)
à la fin I=0  I= N-2*(K-1) = 0  2*(K-1)=N  K= N/2 +1
Remplaçons le k (du tableau) par cette valeur:
CoûtAlgo.A(N)= (1+K+1+K)ϴ(1) = (2K +2)ϴ(1)=(2 (N/2 +1) +2) ϴ(1)= (N+4)ϴ(1)
CoûtAlgo.A(N) = (N+4)ϴ(1) ≈ϴ(N) K
Calcul du Nbre-itération: K pour L’ Algorithme C
Algo. C Algo. C
…
A l’étape 1, I=1
Début
A l’étape 2, I=2*1=22-1 1. i =1
2. tant que i <= N faire
A l’étape 3, I= 2*2 *1=22= 23-1
3. i = i*2
A l’étape 4, I= 2*2*2 *1= 23= 24-1 ftq
A l’étape K, I= 2K-1 Fin
…
A la fin I=N  I= 2K-1 = N  K= logN +1

CoûtAlgo.C(N)=(1+K+1+K)ϴ(1)= (2K +2)ϴ(1)=(2 (logN +1) +2) ϴ(1)= (2logN +4) ϴ(1)
CoûtAlgo.C(N) ≈ ϴ(logN)
 Calcul du Nbre-itération: K pour L’ Algorithme D
Algo. D Algo. D
A l’étape 1, I=N …
Début
A l’étape 2, I=N/2 1. i = N
A l’étape 3, I= N/2*2 2. tant que i >= 1 faire
3. i = i / 2
A l’étape 4, I= N/2*2*2= N/ 24-1 - ftq
A l’étape K, I= N/2K-1 Fin
…
A la fin I=1  I= N/2K-1 = 1 alors 2K-1 = N  K= logN +1

CoûtAlgo.D(N)= (1+K+1+K)ϴ(1)=(2K +2)ϴ(1)=(2 (logN +1) +2)Ѳ(1)= (2logN +4) ϴ(1)

CoûtAlgo.D(N) ≈ ϴ(logN)
Exemple 5:
Analyser la complexité de l’ algorithme suivant : Algorithme principal
Déclaration
Procédure foo (donnée/sortie x, n : entiers) ;
Déclaration un, n : entiers
i : entier ; Début
Début 6. lire(n)
1. Pour i  1 jusqu’à n faire
7. un  0 ;
2. x  x + bar(i, n)
finpour 8. foo (un, n) ;
Fin 9. écrire(bar(n, n))
Fonction bar (données x, n : entiers) : entier
Déclaration Fin
i : entier ; Complexité d’un Algo avec sous-Algos (Proc/fonc):
Début 1. Commencez par calculer la Complexité du
3. Pour i =1 jusqu’à n faire sous-Algo de base (pas d’appel dedans)
4. xx+i 2. Remontez dans les appels et calculer la
finpour Complexité de chq sous-Algo
5. retourner(x) 3. A la fin sommez le tout
Fin
1-Nous commençons par la fonc bar qui ne fait aucun appel à d’autres sous-algorithmes.
Fonction bar(….) : entier • Les actions 3 et 4 sont exécutées respectivement
Début
3. Pour i =1 jusqu’à n faire n+1 et n fois.
4. x=x + i  L’action 5 est exécutée une seule fois.
finpour
Coûtbar(n) = ( n+1 + n +1) ϴ(1)
5. retourner(x)
Fin Coûtbar(n)= (2n +2) ϴ(1) ≈ ϴ(n)
2-Puis, nous analysons la proc foo :
 L’action 2 a normalement une complexité de l’ordre
Procédure foo (….) de ϴ(1), mais il y a un appel à la fonction bar,
Début donc le temps d’exécution de l’action 2 est :
1. Pour i  1 jusqu’à n faire
2. x  x + bar(i, n) ϴ(1) + ϴ(n) = ϴ(n).
finpour  Les lignes 1 et 2 se répètent, n+1 et n fois, donc la
Fin complexité de la procédure foo est de l’ordre de
Coûtfoo(n)= (n+1) ϴ(1) + (n* ϴ(n)) ~ ϴ(n2).
Coûtfoo(n)~ ϴ(n2).
3- Finalement, nous analysons l’algorithme principal. Début
6. lire(n)
7. un  0 ;
8. foo(un, n) ;
9. écrire(bar(n, n))
Fin
 La complexité de chacune des actions 6 et 7 est de l’ordre θ(1).
 La complexité de l’appel à foo (à la ligne 8) est de l’ordre de θ(n2).
 La complexité de l’action écrire (de ligne 9) égale (à la complexité
de l’opération de l’écriture + la complexité de l’appel de fonction bar),
donc : θ(1) + θ(n).
Donc, le temps d’exécution total pour l’algorithme principal est :
Coût algorithme principal (n) =θ(1) + θ(1) + θ(n2) + θ(n) ≈ θ(n2)
Coût algorithme principal (n) ≈ θ(n2)