2éme année Ingénieurs

PR. BELALA Faiza

Semestre 01-2023/24

1
 Révision
 Complexité algorithmique
 Algorithmes de Tri
 Les arbres
 Récap, et évaluation

Chapitre 01_ALCO Pr F. BELALA 2

 But:

Comparer théoriquement des algorithmes

Calculer le temps d'exécution théorique d'un algorithme
simple
Identifier la difficulté de calcul du temps d'exécution d'un
algorithme récursif

Chapitre 01_ALCO Pr F. BELALA

3
 Sans entrer dans les détails mathématiques, le calcul de
l’efficacité d’un algorithme (sa complexité algorithmique)
consiste en la recherche de deux quantités importantes,

1. La première quantité est l’évolution du nombre d’instructions de

base en fonction de la quantité de données à traiter (par exemple,
pour un algorithme de tri, il s'agit du nombre de données à trier),
2. La seconde quantité estimée est la quantité de mémoire
nécessaire pour effectuer les calculs.

Chapitre 01_ALCO Pr F. BELALA 4

 On appelle complexité d’un algorithme A pour une
donnée d de taille n la durée d’exécution de l’algorithme
A pour cette donnée : CoûtA(d)

 On cherche à déterminer une mesure en temps

exprimant la complexité intrinsèque des algorithmes
indépendamment de leur implémentation et non le
temps d'exécution exact d'un algorithme donné.

 Hypothèses:
1. Une mesure de taille de donnée
2. Une unité d’évaluation

Chapitre 01_ALCO Pr F. BELALA 5

 Les principales notions mathématiques dans le calcul du
coût d’un algorithme précis sont les notions de
domination (notée θ(f(n)), « grand o »), où f est
une fonction mathématique de n. n est une variable
désignant la quantité d’informations (en bits, en nombre
d’enregistrements, etc.) manipulée dans l’algorithme.

 En algorithmique, on s’intéresse bien souvent à des

ordres de grandeurs et non à des valeurs exactes.

 On utilise très souvent la notation g = θ(f) pour dire que

la fonction g est de l’ordre de f.

 Les ordres de grandeurs qu’on rencontre le plus

souvent en algorithmique sont : Log(n), n2, n3, n4, nn, 2n,
n!

Chapitre 01_ALCO Pr F. BELALA 6

 Ordre de grandeur du temps nécessaire à l'exécution d'un algorithme d'un
type de complexité donné

Temps Type de complexité Temps pour Temps pour Temps pour Temps pour n=10000 Temps pour Exemple de problème
θ( ) n=5 n=10 n=1000 n=1000000

θ(1) Complexité constante 10 ns 10 ns 10 ns 10 ns 10 ns Accès tableaux

θ(log(n)) Complexité logarithmique 10 ns 10 ns 30 ns 40 ns 60 ns Dichotomie

θ(Ön ) Complexité 22 ns 32 ns 316 ns 1µs 10 µs

racinaire

θ(n) Complexité linéaire 50 ns 100 ns 10 µs 100µs 10ms Parcours de liste

Θ(nlog(n) ) Complexité quasi linéaire 50 ns 100 ns 10 µs 100,5µs 10050µs Triangulation de Delaunay

θ(n2) Complexité quadratique 250 ns 1µs 625 µs 1s 2,8 heures Parcours de tableaux de
(polynomiale) deux dimensions

θ(n3 ) Complexité cubique 1,25 µs 10 µs 10s 2,7 heures 316 ans Multiplication matricielle
(polynomiale) non optimisée

θ(n! ) Complexité factorielle 1,2 µs 36ms astronomique astronomique Problème du voyageur de

commerce (avec une
approche naive)

2n 1000µs 1014 siècles astronomique astronomique

Chapitre 01_ALCO Pr F. BELALA

7
Comparaison de nlog(n) et de n2.

Chapitre 01_ALCO Pr F. BELALA 8

 Déterminer la complexité d’un algorithme A revient à
trouver un ordre de grandeur pour la fonction coûtA(n)
représentant le temps d’exécution de cet algorithme en
fonction de la taille n des données d’entrée et les
opérations fondamentales.

Chapitre 01_ALCO Pr F. BELALA 9

Instruction simple Séquence Choix Répétition

θ(1) (indépendant
de n). Coût séquence(d) Coût Choix(d) = Coût Boucle(d) =
=∑i=1...n coût coût évaluationcondition(d) coût évaluation-condition-
instruction i(d) +
•Lecture/Ecriture, sortie(d) +
Max(coûtséquence1(d), coût séquence(d)
Comparaison,
coûtséquence2(d))
Affectation, Appel
de S/Pgme

Chapitre 01_ALCO Pr F. BELALA 10

1. Pour I←2 jusqu’à n pas 1 faire
2. somme← somme + I
fin pour

Algorithme moyenne_de_n_nombre
Déclaration
n, somme, i, nombre : entier /* N doit être évidement ≠ 0 */
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

Chapitre 01_ALCO Pr F. BELALA 11

 Donc, le temps d’exécution pour cet algorithme sera :
coûtA(n) = [1+1+1+(n+1)+n+n+n+1] θ (1) = (4n + 5) θ (1) ~ θ (n).
Actions Nombre de fois Temps d'exécution (ordre de
grandeur)

1 1 θ (1).

2 1 θ (1).

3 1 θ (1).

4 n+1 (n+1)θ (1).

5 n nθ (1).

6 n nθ (1).

7 n nθ (1).

8 1 θ (1).

Chapitre 01_ALCO Pr F. BELALA 12

 Algorithme TRI
1. Pour i←1 jusqu’à m-1 faire
2. min_pos ← i;
3. min ← t[min_pos];
4. pour j← i+1 jusqu’à m faire
5. si (t[j] < min) alors
6. min_pos ← j
7. min ← t[min_pos]
Finsi
Finpour
8. t[min_pos] ← t[i];
9. t[i] ← min
Finpour

Chapitre 01_ALCO Pr F. BELALA 13

D’où la complexité maximale est:
coûtTRI(m) = [(m) + 4(m − 1)] θ(1) + [m(m+1)/2 −1] θ(1) + 3[m(m−1)/2] θ(1)
= [m + 4m − 4 + (m2+m)/2 − 1 + (3m2−3m)/2] θ(1)
= (5m − 5 + 2m2 − m) θ(1)
1. L’action
= (2m2 1+est −5) θ(1)m fois (m − 1 + 1);
4mexécutée
2. ~ θactions
Les (m2) 2, 3, 8, 9 (chacune des actions a une complexité de l’ordre de θ(1)) sont
exécutées (m − 1) fois, une fois sur chaque itération de la boucle externe.
3. A la première itération ( i = 1):
• l’action 4 est exécutée m fois;

• l’action 5 est exécutée m − 1 fois,

• et en supposant le pire 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.
4. A la deuxième itération ( i = 2),
• l’action 4 est exécutée m − 1 fois

• et les actions 5, 6 et7 sont exécutées m-2 fois, etc.,

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

• et les actions 5, 6, 7 sont exécutés (m − 1)+(m − 2)+...+2+1 = m(m−1)/2 fois.

5. Etc., jusqu’à la dernière itération ( i = m-1), tout en considérant la somme des n

termes d’une suite arithmétique : n*(u1 +u2)/2, u1 et u2 étant le premier et le dernier
termes de cette suite.

Chapitre 01_ALCO Pr F. BELALA 14

Algo. A Algo. B
… …
Début Début
1. i  N 1. i1
2. tant que i >= 0 Faire 2. tant que i <= N faire
3. i  i – 2 3. J 1
fintq 4. tant que J <= N faire
Fin 5. J J+1
ftq
6. i i+1
ftq
Fin

Chapitre 01_ALCO Pr F. BELALA 15

Algo. C Algo. D
… …
Début Début
1. i  1 1. i  N
2. tant que i <= N faire 2. tant que i >= 1 faire
3. i  i*2 3. i  i / 2
ftq ftq
Fin Fin

Chapitre 01_ALCO Pr F. BELALA 16

A l’étape 1, I=N
A l’étape 2, I=N-2
A l’étape 3, I=N-2*2
A l’étape K, I= N-2*(K-1)
…
A la fin I=0  N-2*(K-1) = 0  K= N/2 +1

A l’étape 1, I=1
A l’étape 2, I=2*1
A l’étape 3, I= 2*2 *1

A l’étape K, I= 2K-1
…
A la fin I=N  2K-1 = N  K= logN +1

Chapitre 01_ALCO Pr F. BELALA 17

 Des comportements différents suivant la disposition des données à
traiter.

 Exemple: Imaginons que l’on cherche un nom dans un annuaire

téléphonique et que notre algorithme consiste à lire tous les noms
depuis le début jusqu’à ce qu’on trouve le bon. Si on a beaucoup de
chance, le nom cherché est le premier. Si, au contraire, on n’a pas
de chance du tout, le nom cherché se trouvera en dernier. En
moyenne, on trouvera le nom après avoir parcouru environ la moitié
des pages de l’annuaire.

• Premier cas : θ(1)

• Deuxième cas : θ(n)
• Troisième cas: θ(n/2)

Chapitre 01_ALCO Pr F. BELALA 18

1. Complexité dans le pire des cas :
MaxA(n) = max{coûtA(di), di  D}
D est l’ensemble des entrées de taille n, selon leur disposition.

2. Complexité dans le meilleur des cas :

MinA(n) = min{coûtA(di), di  D}

3. Complexité en moyenne :
MoyA(n) = diD p(di) . coûtA(di)

où p(di) est la probabilité d'avoir en entrée la donnée di parmi toutes les données
de taille n.
Si toutes les données sont équiprobables, alors on a,

 MoyA(n) = 1/|D| diD coûtA(di)

Chapitre 01_ALCO Pr F. BELALA 19

 Soit T un tableau de taille n contenant des nombres entiers de
1 à k. Soit a un entier entre 1 et k. La fonction suivante
retourne l'indice i de l'un des éléments du tableau lorsqu'il est
égal à a, et 0 sinon.
Fonction Proc(Données n, a : entiers, Donnée T: Tab[n] d'entiers ) : entier
Déclarations
i, mem: entier;
Début
mem  0
Pour i =1 jusqu’à n faire
si T[i]=a alors
mem  i
i n
finsi;
finpour
Retourner(mem);
Fin
Chapitre 01_ALCO Pr F. BELALA 20
 Pour les appels de procédures/fonctions, s’il n’y a pas
récursivité, la complexité d’un sous-programme 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.

Chapitre 01_ALCO Pr F. BELALA 21

 Instruction Nombre de fois Ordre de grandeur
s
Fonction factoriel (var n: entier): entier
Déclarations
Fact, i: entiers 1 1 (1)

Début 2 n-2+1+1=n n(1)

1. fact  1
3 n-1 (n-1)(1)
2. Pour i  2 à n faire
3. fact  fact * i 4 n-1 (n-1)(1)

4. ii+1 5 1 (1)
Finpour
5. retourner fact Coût (n) = (1) + n(1) + (n-1)(1)+ (n-1)(1) + (1)=
Factoriel
3n(1)  (n)
Fin

Chapitre 01_ALCO
Pr F. BELALA 22
Fonction factoriel (var n: entier): entier
Déclarations
Fact, i: entiers
Début
1. Si n==0 alors retourner (1)

2. Sinon retourner n*factoriel(n-1)

Fsi
Soit c(n): la nombre de
Fin
multiplications effectuées dans le
calcul de factoriel(n).
On a: c(n)=c(n-1)+1, c(1)=0
Chapitre 01_ALCO Pr F. BELALA 23
 Complexité d’une fonction récursive: résolution d’une équation de
récurrence qui se fait soit avec un outil de calcul formel ou avec des théorèmes
de mathématique.

 Récurrence linéaire:
Par exemple, les formules de récurrences linéaires sont des équations sous la
forme:
un=a1un-1 + a2un-2 +...+akun-k
 Le polynôme caractéristique associé est:

 L’ensemble des solutions forme un espace vectoriel de dimension k

 Si r est racine du polynôme caractéristique alors
est solution de l’équation.

Chapitre 01_ALCO Pr F. BELALA 24

 L'objectif premier d'un calcul de complexité algorithmique est de pouvoir
comparer l’efficacité d’algorithmes résolvant le même problème.

 Ce type de question est primordial, car pour des données volumineuses la

différence entre les durées d'exécution de deux algorithmes ayant la même
finalité peut être de l'ordre de plusieurs jours.

 Les règles que nous utiliserons pour comparer et évaluer les algorithmes ne
sont pas tributaires des qualités d'une machine ou d'un choix de technologie.

 Les résultats de ces calculs fourniront une estimation du temps d’exécution de

l’algorithme, et de la taille mémoire occupée lors de son fonctionnement.

Chapitre 01_ALCO Pr F. BELALA 25