L’énoncé de la première question est un peu vague. Il ne précise pas si l’ordre est sensé être croissant, décroissant ou bien dans les deux sens. Lors du T.P., je vous l’ai simplifié en vous demandant de ne considérer que l’ordre croissant. Pour traiter le cas général, il aurait été plus simple d’écrire une seconde fonction/procédure qui vérifie l’ordre décroissant et puis de vérifier si l’une des deux fonctions retourne une valeur signifiant que la tableau est ordonné, cependant, cela aurait nécessité plus de comparaisons que le stricte minimum et c’est également quelque chose de trivial à coder. C’est pourquoi j’ai souhaité aller un peu plus loin dans cet exemple et vous proposer une solution que je pense être optimale (ou du moins, c’est le mieux que je puisse faire à 6h du matin 😛 ).
Voici donc un exemple de solution complète à la première question du premier exercice de la première série:
Je vous conseille de copier le code ci-dessous vers votre éditeur de code et de le tester après l’avoir lu.
#include
/*
* Je vous conseille de lire le code en lisant les commentaires
* et puis de le lire en faisant abstraction des commentaires.
*/
/**
* Tester si un tableau est trié quelque soit l'ordre ou le sens du tri.
* @param tab
* @param n
* @return 0: si le tableau est vide | 1: s'il est trié | i: position de toute autre valueur ne respectant pas l'ordre établi par les précédantes
*/
int test_tri( const int tab[], const int n ) {
/*
* On passe la taille du tableau en paramètre car sizeof ne pourra pas trouver la taille de tab[]
* car celui-ci est dégradé d'un tableau à un pointeur du premier élément de ce tableau.
*/
if ( 0 == n ) {
/*
* Remarquez que je compare ( 0 == n ) au lieu de ( n == 0 ), il s'agit d'une programmation dite
* défensive (comme la conduite défensive), c'est pour éviter de commettre une erreur en écrivant
* (n = 0), qui est une assignation et qui ne sera pas détectée par le compilateur comme étant
* une erreur.
*/
return 0;
}
/*
* Si le tableau ne contien qu'une ou deux valeurs, alors il est, par définition, trié.
*/
if ( 1 == n || 2 == n ) {
return 1;
}
/*
* On initialise le compteur.
*/
int i = 0;
/*
* Si les premières valeurs sont égales, alors elles ne nous disent pas dans quel sens
* vérifier la continuité de l'ordre. C'est pourquoi nous les faisons défiler et incrémentons
* le compteur jusqu'à trouver une paire de valeurs non-égales.
* Remarquez que dans toutes les boucles, nous comparons le compteur (i) à (n - 1) et non pas à (n),
* c'est pour pouvoir, à la fin, comparer les cases (n - 2) et (n - 1) au lieu de (n - 1) et (n) car la
* case (n) est en réalité au-delà des bornes du tableau vu qu'un tableau de (n) valeurs
* va de (0) à (n-1) et non de (1) à (n).
*/
while ( n - 1 > i /* version défensive de: i < n - 1 */ && tab[i] == tab[i+1] ) {
i++;
}
if ( tab[i] < tab[i+1] ) { while ( n - 1 > i ) {
if ( tab[i] > tab[i+1] ) {
return i+1;
}
i++;
}
}
else {
while ( n - 1 > i ) {
if ( tab[i] < tab[i+1] ) {
return i+1;
}
i++;
}
}
return 1;
}
/**
* Affichage d'un message adapté au résultat du test de tri.
* @param resultat
*/
void traitement_du_test_de_tri( const int resultat ) {
if ( 0 == resultat ) {
printf("Le tableau est vide!\n");
}
else if( 1 == resultat ) {
printf("Le tableau est trié!\n");
} else {
printf("Le tableau n'est pas trié. Problème à la position: %d\n", resultat);
}
}
int main() {
int n1 = 6, n2 = 7, n3 = 6, n4 = 7;
int tab1[] = {2, 5, 7, 11, 15, 28};
int tab2[] = {23, 27, 13, 41, 24, 39, 47};
int tab3[] = {28, 15, 11, 7, 5, 2};
int tab4[] = {47, 39, 24, 41, 13, 27, 23};
int resultat1 = test_tri( tab1, n1);
int resultat2 = test_tri( tab2, n2);
int resultat3 = test_tri( tab3, n3);
int resultat4 = test_tri( tab4, n4);
traitement_du_test_de_tri( resultat1 );
traitement_du_test_de_tri( resultat2 );
traitement_du_test_de_tri( resultat3 );
traitement_du_test_de_tri( resultat4 );
return 0;
}
Si vous avez des questions, des remarques ou des critiques, n’hésitez pas à me les communiquer en classe ou à travers le formulaire de commentaires ci-dessous.