serie N°1

Institut Supérieur de Gestion de Tunis
Enseignants : Moez Hammami, Chaouki Bayoudhi
Année Universitaire : 20112 /2013
Série 1 : Notions de Complexité
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)
c- Montrer que si f(n)
d- Montrer que S(n)T(n)
O(g(n))
O(g(n)), alors S(n) + T(n)
O(g(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.
1
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 :
Ci,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)
2
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 ai sont des nombres premiers tels que
ai < aj pour i < j et les bj 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 ai et le deuxième (T[i, 2]) contient bi.
Soient T1 et T2 les tableaux représentant deux entiers n1 et n2. On note taille1 et taille2 les tailles des
tableaux T1 et T2 ( par rapport à la première entrée).
Soit la fonction PGCD suivante :
fonction PGCD (T1 , T2: tableau) : entier
pgcd, p1, p2 : entier
pgcd 1 ; p1 1 ; p2 1
tant que (p1 ≤ taille1) et (p2 ≤ taille2) faire
si T1[p1,1] = T2[p2,1] alors
m min (T1[p1,2], T2[p2,2])
pgcd pgcd [T1[p1,1]]m
p1 p1 + 1
p2 p2 + 1
sinon
si T1[p1,1] < T2[p2,1] alors
p1 p1 + 1
3
sinon
p2
fin si
p2 + 1
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.
4