Université de Bejaia.

Faculté des Sciences Exactes.

Département Informatique

Corrigé des
Travaux Dirigés
Programmation Avancée

Master 1 en Informatique
Options BN: RS & SIA

Prof. BOUALLOUCHE Louiza

1
 Solution de la série 1
Exercice 1

Procédure Produit (var C : Matrice ; A,B : Matrice ; n, m, p : entier) ;

Var i, 𝑗, 𝑘: entier;

Début Nbre d’itérations Coût

Pour i allant de 1à n faire ∑𝑛+1

𝑖=1 1 = 𝒏 + 𝟏 c1

Pour j allant de 1à m faire ∑𝑛𝑖=1 ∑𝑚+1

𝑗=1 1 = 𝒏 ∗ (𝒎 + 𝟏) c2

𝐶[𝑖, 𝑗] ← 0; 𝒏∗𝒎 c3

Pour k allant de 1à p faire 𝒏 ∗ 𝒎 ∗ (𝒑 + 𝟏) c4

𝐶[𝑖, 𝑗] ← 𝐶[𝑖, 𝑗] + 𝐴[𝑖, 𝑘] ∗ 𝐵[𝑘, 𝑗]; 𝒏∗𝒎∗𝒑 c5

Fin pour

Fin pour

Fin pour

Fin

1. La procédure Produit() calcule le produit de deux matrices A et B et le résultat est

dans la matrice C.

2. La complexité de la procédure Produit

Soit ci le coût ou le temps d’exécution de la ième instruction et ni le nombre d’itérations de

la ième instruction ci*ni

Par exemple : la 2ème instruction est exécutée m+1 pour chaque i allant de 1 à n donc
𝑛2 = ∑𝑛𝑖=1 ∑𝑚+1 𝑛
𝑗=1 1 = ∑𝑖=1(𝑚 + 1) = 𝑛 ∗ (𝑚 + 1)

Le coût ou le temps d’exécution de la 2ème instruction est alors c2* 𝒏 ∗ (𝒎 + 𝟏).

Le coût ou le temps d’exécution de l’algorithme est alors :

T(n, m, p)= c1*(𝑛 + 1)+c2* (𝑛 ∗ (𝑚 + 1))+c3* (𝑛 ∗ 𝑚)+c4*(𝑛 ∗ 𝑚(𝑝 + 1))+c5*(𝑛 ∗ 𝑚 ∗ 𝑝)

2
T(n) = A*n*m*p + B*n*m+ C*n + D.

Remarque. La complexité est alors de l’ordre polynomial de degré 3.

En effet,

Si n=m=p T(n)= c1*(𝑛 + 1)+ c2* (𝑛 ∗ (𝑛 + 1))+c3* (𝑛 ∗ 𝑛)+c4*(𝑛 ∗ 𝑛(𝑛 + 1))+c5*(𝑛 ∗ 𝑛 ∗ 𝑛)

=( c5+c4)*n3 +(c4+c3+c2)*n2+(c2+c1)*n+c1

T(n) = A*n3 + B*n2+ C*n+D = O(n3)

Sinon T(k) <= A*k3 + B*k2+ C*k+D = O(k3) avec k = max(n, m, p).

3
Exercice 2

1. Fonction qui retourne la somme des éléments de MAT

Fonction sommeMAT(MAT : Matrice ; n :entier) : Real ;

Var : i, j : entier ;

Som : real ;

Début

𝑆𝑜𝑚 ← 0; c1 1

Pour i allant de 1 a n faire c2 n+1

𝒏+𝟑
Pour j allant de 1 a i faire 𝒄𝟑 ∑𝒏𝒊=𝟏(𝒊 + 𝟏) = 𝒏
𝟐

𝒏+𝟏
𝑆𝑜𝑚 ← 𝑆𝑜𝑚 + 𝑀𝐴𝑇[𝑖, 𝑗]; 𝑐4 ∑𝒏𝟏 𝒊 = 𝒏
𝟐

Fin pour

Fin pour

Retourner Som ; c5 1

Fin

2. Complexité de la fonction sommeMAT

𝑛+3 𝑛+1
T(n)= c1*1+c2* (n+1) + c3* 𝑛 +c4* 𝑛 + c5
2 2

= ((c3 + c4)/2)*n2+ (c2+3*c3/2+c4/2)*n + c1+c2 +c5

T(n)= A*n2 + A*n + C

Avec A = (c3 + c4)/2 B = c2+ (3*c3+c4)/2 et C= c1+c2+ c5

La complexité est alors de l’ordre O(n2) donc de type quadratique.

3. La complexité de la fonction sommeMAT en nombre d’additions. Il y a une seule

addition dans la 4ème instruction à l’intérieur des 2 boucles imbriquées et qui est donc
𝑛+1
répétée 𝑛 fois (c1 = c2 = c3 = c5 = 0 et c4 = 1).
2

𝒏+𝟏
D’où en nombre d’additions T(n) = 𝒏 𝟐

4
Exercice 3

1. Une fonction efficace qui calcule 𝑠𝑜𝑚 = 1 + 𝑥 + 2𝑥 2 + 3𝑥 3 + ⋯ + 𝑛𝑥 𝑛

Il serait absurde d’invoquer une fonction qui calcule la puissance de x pour le calcul de
chaque terme de l’expression de som. Ainsi, il suffit d’utiliser la relation de récurrence
suivante xi = xi-1*x.

Fonction somme (x : réel, n : entier): réel ;

Var i : entier ; y : réel ; Som : réel ;
Début

𝑆𝑜𝑚 ← 1;

𝑦 ← 𝑥;
Pour i allant de 1 a n faire

𝑆𝑜𝑚 ← 𝑆𝑜𝑚 + 𝑖 ∗ 𝑦;

𝑦 ←𝑦∗𝑥;
Fin pour

Retourner 𝑆𝑜𝑚
Fin.

2. Complexité en nombre de multiplications.

On a 2 multiplications à l’intérieur de la boucle Pour répétées n fois. D’où la complexité

T(n) = 2*n multiplications.

3. On ne peut pas faire mieux puisque l’on effectue le minimum de multiplications. En

effet, pour chaque terme i, on doit effectuer au moins 2 « * », une pour multiplier le
terme par i et une autre pour obtenir xi en fonction de xi-1 (terme précédent).
L’algorithme est alors optimal.

5
Exercice 4

1. Fonction itérative qui retourne la factorielle de n.

n ! = 1 si 0 < n < =1 et n ! = 2*3*…*n si n >1

Fonction fact (N : entier) : entier;

Var i, F : entier;
Début
𝐹 ← 1;
Pour 𝑖 allant de 2 à N faire
𝐹 ←𝐹 ∗𝑖 ;
Fin pour
Retourner F :
Fin.

2. La complexité de la fonction fact en nombre de multiplications :

T(N) = N-1 multiplications

3. Fonction itérative qui retourne 𝐶𝑁𝑃

Il serait absurde de calculer K! puis M! pour calculer K !/M!. En effet, il est toujours
possible d’effectuer une simplification.

Ainsi
N! N * ( N − 1) * ( N − 2) * ... * (N − P + 1) * (N − P ) * ... * 2
C NP = = =
P!*(N − P )! P!*(N − P )!
N * ( N − 1) * ( N − 2) * ... * (N − P + 1)
P!
Nous avons alors simplifié par le facteur (N − P )! ; cela nous fait gagner 2*(N-P-1)
multiplications. Ce qui n’est pas négligeable.

Fonction combin(N, P : entier ): entier ;

Var i, comb : entier ;
Début
comb ← 𝑁 − 𝑃 + 1;
Pour i allant de 𝑁 − 𝑃 + 2 à N faire
𝑐𝑜𝑚𝑏 ← 𝑐𝑜𝑚𝑏 ∗i ;
Fin pour
Pour 𝑖 allant de 2 à P faire
𝑐𝑜𝑚𝑏 ← 𝑐𝑜𝑚𝑏/𝑖; ;
Fin pour
Retourner comb ;
Fin.

4. La complexité de la fonction comb en nombre de multiplications et son ordre de

grandeur.

6
• Il y a une multiplication dans la 3ème instruction qui se répète
N-(N-P+2)+1=P-1 fois et une division (qui a le même coût que la
multiplication) dans la 5ème instruction qui se répète P-1 (le coût de calcul de P!)
et une division.
D’où le nombre de multiplications et divisions nécessaires est

T(n,p) = T(p)= P-1+P-1 + 1=2P-2 multiplications

• L’ordre de grandeur de cette fonction est O(P), sa complexité est donc linéaire.

7
Exercice 5

1. Algorithme de recherche de maximum dans un tableau A à n éléments

Algorithme max ;
Var A : tableau[1..100], n, max, i : entier;
Début
𝑚𝑎𝑥 ← 𝐴[1];
Pour i allant de 2 a n faire
Si 𝐴[𝑖] > max alors
𝑚𝑎𝑥 ← 𝐴[𝑖];
Fin si
Fin pour
Ecrire 𝑚𝑎𝑥;
Fin.

2. La complexité de l’algorithme max en nombre de comparaisons

T(n) = n-1 comparaisons.

3. L’algorithme est optimal, car tout élément excepté le max doit avoir perdu une
comparaison, sinon on ne peut pas savoir qu’il n’est pas le max. Ce qui donne lieu à
n-1 comparaisons.
Conclusion. Tout algorithme de recherche du min ou max doit effectuer au moins n-1
comparaisons.

8
Exercice 6

1. Algorithme de recherche de deuxième plus grand élément

Algorithme max2

Var A : tableau[1..100], n, max, i : entier;

Début

Si 𝐴[1] ≥ 𝐴[2] 𝒂𝒍𝒐𝒓𝒔

𝑚𝑎𝑥1 ← 𝐴[1];
1 comparaison
𝑚𝑎𝑥2 ← 𝐴[2];

Sinon

𝑚𝑎𝑥2 ← 𝐴[1];

𝑚𝑎𝑥1 ← 𝐴[2];

Fin si

Pour i allant de 3 à n faire

Si (𝐴[𝑖] ≥ 𝑚𝑎𝑥1) alors

𝑚𝑎𝑥2 ← 𝑚𝑎𝑥1;

𝑚𝑎𝑥1 ← 𝐴[𝑖];

Sinon
2(n-2) comparaisons dans le pire
Si (𝐴[𝑖] ≥ 𝑚𝑎𝑥2) alors cas

𝑚𝑎𝑥2 ← 𝐴[𝑖];

Fin si

Fin si

Fin pour

Fin

9
 2. La complexité de l’algorithme max2 en nombre de comparaisons
T(n)= 1+2(n-2) = 2n-3 comparaisons.

3. Chercher le maximum en utilisant la méthode de tournoi.

a. Principe. Les comparaisons sont organisées comme dans un tournoi.
▪ 1ère étape. Les valeurs sont comparées par paires. Dans chaque paire, il y a bien
évidemment un plus grand élément (le vainqueur) et un plus petit (le vaincu ou le
battu).
▪ 2ème étape. Les éléments vainqueurs sont à leur tour comparés 2 à 2.
▪ On répète le processus récursivement jusqu’à ce qu’il n’y ait plus qu’un seul
élément qui est alors le plus grand.

Illustration par un exemple.

Soit à calculer le max des éléments 13, 5, 28, 17, 30, 4, 19 14

13 5 28 17 30 25 19 14
Niveau 3

13 28 30 19
Niveau 2

28 300
Niveau 1

Niveau 0 30

Le max des 8 éléments donnés dans le tableau est alors 30.

b. La complexité de cette méthode en nombre de comparaisons est:

Une comparaison au niveau 1, 2 au niveau 2, 22 au niveau 2, … , 2k au niveau k,

On s’arrête lorsque 2k = n/2 (comparaisons).

T(n) = 1 + 2 + 22 +…+ 2i + … + 2k = (1- 2k+1)/(1-2) = 2k+1 -1

Avec 2k = n/2 donc 2k+1 = n.

10
Ce qui conduit à T(n) = n-1 comparaisons.

Dans l’exemple proposé, on a effectivement effectué 7 comparaisons pour trouver le max.

4. Dans combien de comparaisons, le deuxième plus grand élément de l’ensemble a-t-il

été trouvé être le plus petit des deux éléments comparés ?

Le 2ème plus grand n’est plus petit que devant le plus grand élément. Il n’a donc perdu que
dans une comparaison qui est celle avec le plus grand élément.

5. L’algorithme du 2ème plus grand élément

1. On cherche d’abord le max selon la méthode du tournoi (décrite en 3)
2. On obtient le 2ème max (selon la méthode du tournoi) en recherchant l’élément max
parmi ceux qui ont été éliminés du tournoi lors d’une comparaison avec l’élément
max (les éléments battus par le max).

Illustration: pour trouver le max 2 on cherche d’abord le max 1 par la méthode du tournoi (le
max est alors l’élément 30), ensuite pour trouver le max 2, on cherche le plus grand parmi les
éléments battus par le max 1 (25, 19 et 28) par la méthode du tournoi.

13 5 28 17 30 25 19 14
Niveau 3

13 28 30 19
Niveau 2

28 30
Niveau 1

Niveau 0 30

25 19 28

25 28

28

11
Le max 2 est alors 28.

6. La complexité de ce nouvel algorithme de recherche du max2 est la complexité de la

recherche du max 1 + la complexité de la recherche du max2 à partir de max1.
1- La recherche du max1 nécessite T1(n) = n-1 comparaisons
2- La recherche du max2 nécessite T2(n) = m-1 où m est le nombre d’éléments
auxquels l’élément max1a été comparé. Il s’agit de trouver alors m en fonction de
n.

On a un élément par niveau de l’arbre initial, donc m est =

1 élément au niveau 1(2 éléments) + 1 élément au niveau 2 (22 éléments) + …+ 1 élément au

niveau m (2m éléments = n).

Dans le pire cas (n impair) 𝑚 = ⌈𝑙𝑜𝑔2 (𝑛)⌉

D’où T2(n) = 𝑚 − 1 = ⌈𝑙𝑜𝑔2 (𝑛)⌉ − 1,

d’où T(n) = n + ⌈𝒍𝒐𝒈𝟐 (𝒏)⌉ - 2

Dans l’exemple proposé on a effectivement effectué 9 comparaisons pour trouver le max 2.

PS. En théorie des graphes, dans le pire cas m = la hauteur de l’arbre -1. Par ailleurs, un
arbre parfait à n feuilles est de hauteur ⌈log 2 (𝑛)⌉. D’où T(n) = n + ⌈𝑙𝑜𝑔2 (𝑛)⌉ - 2

12
Exercice 7

1. Algorithme naïf de recherche du maximum et du minimum

Algorithme Max-Min

Var A : tableau [1..100] , n, i, max, min : entier;

Début

Lire (n) ;

𝑚𝑎𝑥 ← 𝐴[1];

𝑚𝑖𝑛 ← 𝐴[1];

Pour i allant de 2 à n faire

Si 𝑚𝑎𝑥 < 𝐴[𝑖] alors

𝑚𝑎𝑥 ← 𝐴[𝑖];

Sinon

Si 𝑚𝑖𝑛 > 𝑇[𝑖] 𝒂𝒍𝒐𝒓𝒔

𝑚𝑖𝑛 ← 𝑇[𝑖];

Fin si

Fin si

Fin pour

Fin.

2. La complexité de cet algorithme en nombre de comparaisons. On a 2 opérations de

comparaison dans la boucle. La première s’exécute pour chaque valeur de i donc n-1
fois. La 2ème comparaison ne s’exécute que si la première condition n’est pas vérifiée.
La complexité dépend alors des données.

▪ Dans le pire cas (tableau trié par ordre décroissant)

On T(n) =2*(n-1) comparaisons.

▪ Dans le meilleur cas (tableau trié par ordre croissant)

T(n) = n-1 comparaisons.

▪ Dans le moyen cas

On T(n) = 3*(n-1)/2 comparaisons.

13
 3. Un algorithme plus efficace.
Principe.
1. On compare par paires les éléments de l’ensemble. On met d’un côté les plus grands
éléments (par exemple dans les cases paires du tableau) et de l’autre les plus petits.
2. On recherche le minimum parmi tous les plus petits éléments.
3. On recherche le maximum parmi tous les plus grands éléments.

Algorithme Max-Min-Efficace ;
Var A : tableau [1..100] ; n, n1, i, max, min, x : entier;
Début
Lire (n) ; n1← 𝑛 − 1 ;
Pour i allant de 1 à n1 à pas 2 faire
Si A[i] > A[i+1] alors
𝑥 ← 𝐴[i];
𝑛
A[i] ← 𝐴[i + 1]; ⌊2 ⌋ Comparaisons

𝐴[i + 1] ← x;
Fin si
Fin pour
min ← 𝐴[1];
Pour i allant de 3 à n à pas 2 faire
Si A[i] < min alors 𝑛
⌈ 2⌉ − 1 Comparaisons
min ← 𝐴[i];
Fin si
Fin pour
max ← A[2];
Pour i allant de 4 à n à pas 2 faire
Si 𝐴[i] > max alors 𝑛
⌊2 ⌋ − 1 Comparaisons
max ← A[i];
Fin si
Fin pour
Si n mod 2 <> 0 alors
Si 𝑨[n] > max alors 1 Comparaison significative
max ← A[𝑛];
Fin si
Fin si
Fin.

14
 4. La complexité de l’algorithme efficace en nombre de comparaisons
𝑛 𝑛 𝑛 𝑛
T(n)= ⌊2 ⌋ + ⌈ 2 ⌉ − 1 + ⌊2 ⌋ − 1 +1 =𝑛 + ⌊2 ⌋ − 1 comparaisons

PS. On a négligé la comparaison dans n mod 2 < > 0, qui est instantanée.

Exercice 8

LLC non LLC triée LDC non LDC triée Tableau Tableau
triée triée non trié trié
Recherche (L,x) O(n) O(n) O(n) O(n) O(1) O (1)

Insertion (L,x) O(1) O(n) O(1) O(n) O(1) ou O(n) ou

erreur erreur
Surpression (L,x) O(n) O(n) O(1) O(1) O(n) O(n)
Successeur (L,x) O(n) O(1) O(n) O(1) O(n) O(1)

Prédécesseur (L,x) O(n) O(n) O(n) O(1) O(n) O(1)

Minimum (L) O(n) O(1) O(n) O(1) O(n) O(1)

Maximum (L) O(n) O(n) O(n) O(n) O(n) O(1)

LLC : Liste Linéaire Chainée ;

LDC : Liste Doublement Chainée.
x : Pointeur dans les LLC et LDC ou indice dans le tableau.
Le tri dans toutes les structures de données est considéré dans l’ordre croissant.

15