serie N°1

1
Exercice 1 :
a- Montrer que si f(n) O(g(n)), alors f(n) + g(n) O(g(n)).
b- Montrer que O(f(n) + g(n)) = O(max(f(n),g(n))).
On suppose que S(n) O(f(n)) et T(n) O(g(n))
c- Montrer que si f(n) O(g(n)), alors S(n) + T(n) O(g(n)).
d- Montrer que S(n)T(n) O((f(n)g(n))).
Exercice 2 :
1- Soit A un tableau de n entiers (n ≥ 1)
L’algorithme itératif qui calcule la somme des n éléments d’un tel tableau est le suivant :
A : tableau [1..n] d’entiers
somme : entier
somme 0
pour i de 1 à n faire
somme somme + A[ i]
fin pour
Déterminer la complexité temporelle et spatiale de cet algorithme.
2- Soit la fonction récursive qui calcule la somme des n éléments d’un tableau A.
fonction somme_rec (A : tableau[ 1..n] ; n : entier) : entier
si n ≤ 0 alors
retourner (0)
sinon
retourner (somme_rec(A, n-1) + A[n])
fin si
Calculer la complexité temporelle et spatiale de cette fonction.
Institut Supérieur de Gestion de Tunis Année Universitaire : 20112 /2013
Enseignants : Moez Hammami, Chaouki Bayoudhi
Série 1 : Notions de Complexité

2
Exercice 3 :
On considère deux matrices carrées (d’entiers) d’ordre n, A et B. Le produit de A par B est
une matrice carrée C définie par :
C
i,j
=
1- Nous proposons l’algorithme ci-dessous qui permet de calculer le produit de deux matrices
représentées sous forme de tableaux à deux dimensions.
i, j, k : entier
pour i de 1 à n faire
pour j de 1 à n faire
C[i,j]  0
pour k de 1 à n faire
C[i,j]  C [i,j] + A[i,k] x B[k,j]
fin pour
fin pour
fin pour
a- Calculer la complexité temporelle et spatiale de cet algorithme.
b- Doit on préciser dans quels cas (pire cas, meilleur des cas, cas moyen) cette
complexité est obtenue ?
2- Supposons maintenant que la matrice A est de dimension (m, n) et la matrice B est de
dimension (n, p). L’algorithme qui permet de calculer le produit de ces deux matrices est le
suivant :
i, j, k : entier
pour i de 1 à m faire
pour j de 1 à p faire
C[i,j]  0
pour k de 1 à n faire
C[i,j]  C [i,j] + A[i,k] x B[k,j]
fin pour
fin pour
fin pour
Quelle est alors la complexité temporelle de cet algorithme ?
Exercice 4 :
On considère un tableau A de n éléments, que l’on suppose trié en ordre croissant.
1- Soit la fonction ci-dessous qui permet d’afficher la position d’un élément elt dans un
tableau A. (On suppose qu’elt est bien dans le tableau et qu’on cherche la première
occurrence de cette valeur)

3
fonction recherche_seq (A : tableau ; n, elt : entier) : entier
pos : entier
pos 1
tant que A [pos] ≠ elt faire
pos pos + 1
fin tant que
retourner (pos)
a- A quoi correspond le pire des cas ? En déduire la complexité en O de l’algorithme .
b- A quoi correspond le meilleur des cas ? En déduire la complexité en Ω
ΩΩ
Ω de
l’algorithme .
2- La traduction de l’algorithme itératif sous forme récursive est la suivante :
fonction recherche_seq (A : tableau ; n, elt, j : entier) : entier
si A[ j] = elt alors
retourner (j)
sinon retourner (recherche_seq(A, n, elt, j+1)
fin si
Calculer la complexité de cette fonction récursive.
Exercice 5 :
La décomposition en facteurs premiers d’un nombre entier consiste à représenter cet entier de
la manière suivante : n = où les a
i
sont des nombres premiers tels que
a
i
< a
j
pour i < j et les b
j
sont des entiers strictement positifs.
Un entier n peut donc être représenté par un tableau T à deux entrées. Le premier champ de la
i
ème
position (T [ i,1]) contient a
i
et le deuxième (T[i, 2]) contient b
i
.
Soient T
1
et T
2
les tableaux représentant deux entiers n
1
et n
2
. On note taille
1
et taille
2
les tailles des
tableaux T
1
et T
2
( par rapport à la première entrée).
Soit la fonction PGCD suivante :
fonction PGCD ( T
1
, T
2
: tableau) : entier
pgcd, p1, p2 : entier
pgcd  1 ; p1  1 ; p2 1
tant que (p1 ≤ taille
1
) et (p2 ≤ taille
2
) faire
si T
1
[p1,1] = T
2
[p2,1] alors
m  min (T
1
[p1,2], T
2
[p2,2])
pgcd  pgcd [T
1
[p1,1]]
m
p1  p1 + 1
p2  p2 + 1
sinon
si T
1
[p1,1] < T
2
[p2,1] alors
p1  p1 + 1

4
sinon
p2  p2 + 1
fin si
fin si
fin tant que
retourner (pgcd)
Déterminer la complexité temporelle de la fonction PGCD.
Exercice 6 :
Dans cet exercice on suppose que les éléments à trier sont des entiers stockés initialement
dans un tableau T de taille n. La comparaison et l’échange de deux éléments du tableau sont
supposés être de complexité O(1).
Principe : Le tri à bulle d’un tableau T[1..n] de n éléments consiste, pour i variant de 1 à n -1
à faire « remonter » le plus petit élément du sous tableau T[i..n] en position i par une suite
d’échanges.
Nous proposons dans ce qui suit l’algorithme de la procédure Tri_Bulle :
procédure Tri_Bulle (T :tableau ; n :entier)
i,p :entier
pour i de 1 à n -1 faire
pour p de n à i + 1 faire
si T[p] < T[p-1] alors
échanger T[p] et T[p-1]
fin si
fin pour
fin pour
1- Appliquer l’algorithme de Tri à bulle sur le tableau suivant :
3 1 10 7 2 9 5 14 8 6
2- Déterminer le nombre de comparaisons des éléments effectuées par le tri à bulle sur un
tableau de n éléments.
En déduire la complexité de la procédure Tri_Bulle en fonction de nombre de comparaisons
d’éléments.
3- Déterminer le nombre maximum et le nombre minimum d’échanges exécutés par le tri à
bulle sur un tableau de n éléments.
En déduire la complexité dans le meilleur et dans le pire des cas de la procédure Tri_Bulle en
termes de nombre d’échanges effectués.