Question sur qsort()

Version imprimable

Bonjour tout le monde !

Premier message pour ma part sur ce formidable site que j'ai parcouru de long en large !

Alors voila, je souhaite faire un tri en utilisant Qsort, mais je n'arrive pas à le faire sur le champ que je souhaite ...

Voici ma structure pour un étudiant :
Code:

1 2 3 4 5 6 7 8 9 10 typedef struct { char matricule[25]; /* Matricule unique. */ char nom[20]; char prenom[20]; Adresse adr; double tabCotes[5]; double moyennePourcentage; }Etudiant;
Celle pour l'auditoire :
Code:

1 2 3 4 5 6 7 typedef struct { int nbEtudiants; Etudiant classe[MAX_ETU]; int compteurMatricule; }Auditoire;
Et enfin, ma fonction qSort :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 int fcomp (const void *a, const void *b) { const int *ia = (const int *)a; const int *ib = (const int *)b; return *ia - *ib; } void triSelectif(Auditoire *auditoireA) { int i; printf("%d", auditoireA->nbEtudiants); Sleep(1000); for(i = 0 ; i < auditoireA->nbEtudiants ; i++) qsort(&auditoireA->classe, auditoireA->nbEtudiants, sizeof(Auditoire), fcomp); }
J'aimerai pouvoir faire un tri sur la moyennePourcentage, mais je n'arrive pas à accéder à ce champ, et ainsi la passer à qSort().

Quelqu'un pourrait-il me fournir des conseils ?

Bien à vous,

Mornor.

24/04/2013, 16h01
ternel

Bonjour,
Le tri se fait en utilisant fcomp(a, b), retournant un positif si a est avant b, un négatif s'il est apèrs et 0 s'ils sont équivalents pour le tri.

ton fcomp retourne ceci:

Citation:

traitons a et b comme pointant vers des entiers, alors l'ordre entre les entiers est donné par leur différence (ce qui est globalement vrai pour des entiers).

Il devrait plutot ressembler à

Citation:

traitons a et b comme pointant vers des etudiant, alors l'ordre est donné par l'ordre des moyennes.

Merci beaucoup pour ta réponse !

En somme, si j'ai bien compris, j'ai modifier mon code de la façon suivante :

Code:

1
2
3
4
5
6
7
int fcomp (const void *a, const void *b)
{
    const Etudiant *ia = (const Etudiant *)a;
    const Etudiant *ib = (const Etudiant *)b;
 
    return ia->moyennePourcentage - ib->moyennePourcentage;
}

Code:

1
2
3
4
5
6
7
8
void triSelectif(Auditoire *auditoireA)
{
    int i;
    printf("%d", auditoireA->nbEtudiants); Sleep(1000);
    for(i = 0 ; i < auditoireA->nbEtudiants ; i++)
        qsort(auditoireA->classe, auditoireA->nbEtudiants, sizeof(Auditoire), fcomp);
 
}

Je pense que comme cela, le code fonctionne. Néanmoins, lors de l'affichage,
il n'y a pas de tri effectif :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
void afficherClasse(Auditoire auditoireA)
{
    system("cls");
    printf("Affichage de la classe : \n\n");
    int i = 0;
    if(auditoireA.nbEtudiants != 0){
        for(i = 0 ; i < auditoireA.nbEtudiants ; i++)
        {
            printf("Etudiant %d : \n", i);
            afficherEtudiant(auditoireA.classe[i]);
            printf("\n");
        }
        system("pause");
    }
    else{
        printf("La classe est vide !\n\n");
        system("Pause");
    }
 
    afficherMenu(&auditoireA);
}

Est-ce ma méthode fcomp, ou bien la méthode d'affichage qui pose problème ?

24/04/2013, 16h31
ternel
juste une question, pourquoi trier le tableau autant de fois qu'il y a d'étudiants?

Et dans le tri, ce serait plutot sizeof(Etudiant).

Code:

qsort(void *first_element_adress, int elements_count, int element_size, fcomp_t comparison).
Code:

1 2 long tab[] = {5,3,7,2}; qsort(tab, 4, sizeof (long), min);

Tout à fait, la boucle de tri, était un reste de mes précédents tests, elle n'a donc pas lieu d'être ici.

J'ai fait les modifications nécessaire, mais je n'obtiens toujours pas de tri.
Je n'arrive vraiment pas à comprendre d'ou viens ma faute.

Le code me semble pourtant juste ...
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 int fcomp (const void *a, const void *b) { const Etudiant *ia = (const Etudiant *)a; const Etudiant *ib = (const Etudiant *)b; return (ia->moyennePourcentage) - (ib->moyennePourcentage); } void triSelectif(Auditoire *auditoireA) { qsort(auditoireA->classe, auditoireA->nbEtudiants, sizeof(Etudiant), fcomp); }

24/04/2013, 17h56
edgarjacobs
Hello,

Je ne sais pas ce que contient moyennePourcentage, mais je changerais en tout cas le return de la fonction en
Code:

1 2 return (ia->moyennePourcentage) > (ib->moyennePourcentage); // ou >=
Edit: non, il faut tester ça toi-même (ce n'est pas un booléen qui doit être renvoyé). Mon idée est que moyennePourcentage est un double, et que la fonction va renvoyer du int. Alors si toutes le valeurs sont comprises entre 0. et 1., le retour sera toujours 0
24/04/2013, 19h43
Ngork

Une remarque en passant : ce n'est pas une très bonne idée de faire des appels à une commande système (system("CLS") et system("PAUSE") dans ton code), car ce n'est pas portable ...

Sur le fond, ton qsort paraît maintenant correct, mais cela dépend de ce que tu places dans moyennePourcentage ainsi que le précise edgarjacobs ! :?

Bonsoir,

Merci pour toutes vos réponses !
moyennePourcentage est en effet un double.

Je pensais donc écrire fcomp de cette façon :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 double fcomp (const void *a, const void *b) { const Etudiant *ia = (const Etudiant *)a; const Etudiant *ib = (const Etudiant *)b; return (ia->moyennePourcentage) - (ib->moyennePourcentage); } void triSelectif(Auditoire *auditoireA) { qsort(auditoireA->classe, auditoireA->nbEtudiants, sizeof(Etudiant), fcomp); }
Pour renvoyer la différence entre les moyennePourcentage.

Seulement, cela ne fonctionne pas.

En renvoyant un booléen (double fcomp) , comme le dit edgarJacobs, cela fonctionne une fois, mais à la deuxième exécution, j'obtiens de nouveau un tableau non trié.
A chaque exécution, j'obtiens donc un nouveau classement.

Je sens que nous (vous) êtes tout prêt ... Aussi je continue ardemment à chercher la solution.

Merci d'avance pour votre future aide !

Mornor.

La solution ne serait-elle pas tout simplement:
Code:

1 2 if(ia->moyennePourcentage - ib->moyennePourcentage>0) return(1); // ou >= return(-1);

Ce serait plutot

Code:

1
2
3
double diff = ia->moyennePourcentage - ib->moyennePourcentage
if (diff>0) return 1;
return diff<0 ? -1 : 0;

Merci beaucoup pour votre aide !

J'ai utilisé la version de edgarJacobs (je ne comprends pas le code de leternel)
Voici la solution utilisée :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
int fcomp (const void *a, const void *b)
{
    const Etudiant *ia = (const Etudiant *)a;
    const Etudiant *ib = (const Etudiant *)b;
 
    if( (ia->moyennePourcentage) - (ib->moyennePourcentage) > 0)
        return -1;
 
    else if( (ia->moyennePourcentage) - (ib->moyennePourcentage) == 0)
        return 0;
 
    else
        return 1;
 
}
 
void triSelectif(Auditoire *auditoireA)
{
    qsort(auditoireA->classe, auditoireA->nbEtudiants, sizeof(Etudiant), fcomp);
 
}

Encore un énorme merci pour votre aide.

Mornor.