2.

Quelle est la situation (organisation des données du tableau) du pire des cas de la
fonction fonct2 ?
3. Calculer l’expression de la fonction de temps maximale T(n) (pire des cas) pour la fonction
font2 en fonction de TB(n) qui est la fonction de temps maximale associée à la fonction
fonct1.
4. Si TB(n) a une complexité asymptotique O(n), en déduire celle de T(n).
5. Quelle est la situation (organisation des données du tableau) du meilleur des cas ?

Calculer l’expression de la fonction de temps minimale M(n) (meilleur des cas) pour la fonction
fonct2 en considérant que la fonction fonct1 a une fonction associée MB(n).

3
 Solutions du TD N°2
Exercice 1
1. Il suffit de changer « void TriBulles (int* t, int nbElements) » par « void TriBulles (char* t, int
nbElements) »
2. La succession pour i=0 de changement de « T I M O L E O N »
k=7 T I M O L E N O
k=6 T I M O L E N O
k=5 T I M O E L N O
k=4 T I M E O L N O
k=3 T I E M O L N O
k=2 T E I M O L N O
k=1 E T I M O L N O
3. La succession pour la boucle principale :
i=0 E T I M O L N O
i=1 E I T L M O N O
i=2 E I L T M N O O
i=3 E I L M T N O O
i=4 E I L M N T O O
i=5 E I L M N O T O
i=6 E I L M N O O T

4. Pour i=0 ; nous avons n-1=n-(0+1) comparaisons. Pour i=1, n-2=n-(1+1) comparaisons, …, pour
i=n-2, 1=n-(n-1)=n-((n-2)+1) comparaisons. Donc il y a (n-1) + (n-2) + … + 1 = n(n-1)/2
5. Solution optimale :
void TriBulles (int* t, int nbElements) {
int i, k, echange ;
for (i = 0; i < nbElements-1; i++) {
echange = 0;
for (k = nbElements-1; k > i; k--) {
if (t[k] < t[k-1]) {
echanger(&t[k], &t[k-1]) ;
echange = 1 ;
}
}
If (!echange)
break ;
}
}

6. Au pire des cas, le parcours est complet (tableau inversement trié), donc c’est la situation de la
question 4 : n(n-1)/2. Dans le meilleur des cas, on parcourt la boucle une seule fois et on trouve
un tableau déjà trié, donc : n-1.

Exercice N° 2

4
En triant les deux tableaux dans le même ordre et en comparant leurs contenus.

bool areAnagram(char* str1, int n1, char* str2, int n2)

{
if (n1 != n2)
return false;

sort(str1, n1);
sort(str2, n2);

for (int i = 0; i < n1; i++)

if (str1[i] != str2[i])
return false;

return true;
}

Exercice N°3
Le nombre maximum d'échanges est n. C’est le cas d’un élément se trouvant dans la première
position du tableau puis déplacé à sa fin.

Exercice N°4
Le tri par insertion s'exécute en temps linéaire lorsque toutes les valeurs sont égales

Exercice N°5
Utiliser le tri par sélection car il minimise le nombre d'échanges

Exercice N°6
void Fusionner (int* T, int* T1, int* T2 , int N1, int N2) {
int c = -1, c1 = N1-1, c2 = N2-1;
int i;
do {
c++;
if (T1 [c1] < T2 [c2]) {
T[c] = T2 [c2];
c2-- ;
} else {
T[c] = T1 [c1];
c1--;
}
}
while ((c1 >= 0) && (c2 >= 0));

5
 c++;
if (c1 < 0) {
for (i = c2 ; i >= 0 ; i--) {
T[c] = T2[i];
c++ ;
}
} else {
for (i = c1 ; i >= 0 ; i++) {
T[c] = T1[i] ;
c++ ;
}
}
}

Exercice N°7
1. La fonction fonct1 correspond au tri à bulles. La fonction fonct2 teste si un tableau d’entiers t
est trié par ordre croissant. S’il est trié, elle le retourne tel qu’il est. S’il n’est pas trié, elle fait
appel à la fonction fonct1 qui est le tri à bulles pour le trier puis elle le retourne.

2. La question peut être comprise de deux façons différentes. Soit que l’on considère le pire des
cas pour la fonction 2 indépendamment de l’appel de la fonction 1, soit que le pire des cas
correspond à la situation globale des deux fonctions :
 Si nous incluons la fonction fonct2 dans la situation, c’est-à-dire le pire des cas pour tout
le programme, le pire des cas est celui où le tableau est inversement trié.
 Si nous ignorons l’appel de la fonction fonct2, au pire des cas, les deux derniers éléments
qui se trouvent dans les deux dernières cases sont non ordonnés et tous les éléments
précédents sont triés.

3. Il y a deux situations :

 Si nous incluons la fonction fonct2 dans la situation :

void fonct2 (int * t, int nbElements) {

int i, sorted = 1; // 1
for (i = 0; i < (nbElements-1); i++) { // 1 + 2
if (t[i] > t[i+1]) { // 1 + 1
sorted = 0; // pire des cas => 1
break; // pire des cas => 1
}
}
if (!sorted) // 1
fonct1 (t, nbElements); // TB(nbElement)
}

6
Posons nbElements = n :

T(n) = 1+1+2+1+1+1+1+1+TB(n) = 9 + TB(n)

 Si nous ignorons l’appel de la fonction fonct2 :

void fonct2 (int * t, int nbElements) {

int i, sorted = 1; // 1
for (i = 0; i < (nbElements-1); i++) { // 1 + 2*(nbElement-1) + 2*(nbElement-2)
// (-1) pour pire des cas => break s’exécute
// i++ n’est pas exécuté à la fin
if (t[i] > t[i+1]) { // (1 + 1)*(nbElement – 1)
sorted = 0; // pire des cas => 1
break; // pire des cas => 1
}
}
if (!sorted) // 1
fonct1 (t, nbElements); // TB(nbElement)
}

Posons nbElements = n :

T(n) = 1+1+2(n-1)+2(n-2)+2(n-1)+1+1+1+TB(n) = 6n - 3 + TB(n)

4. La complexité asymptotique de T(n) est O(n) + O(n) = O(2n) = O(n)

5. Le meilleur des cas est celui quand le tableau est déjà trié

6.

void fonct2 (int * t, int nbElements) {

int i, sorted = 1; // 1
for (i = 0; i < (nbElements-1); i++) { // 1 + 2*nbElement + 2*(nbElement-1)
if (t[i] > t[i+1]) { // (1 + 1)*(nbElement – 1)
sorted = 0; // meilleur des cas => 0
break; // meilleur des cas => 0
}
}
if (!sorted) // 1
fonct1 (t, nbElements); // 0 puisque tableau trié
}

Posons nbElements = n :

M(n) = 1+1+2n+2(n-1)+2(n-1)+0+0+1+0 = 6n – 1