Discussion :

[souviron34]

qu'est-ce qui ne marche pas ?

Qu'as-tu dans tes affs ?

Tu as bien tes 3 éléments ?

Comment affiches-tu ?

un exemple stp..

Et d'autre part, pourquoi 'je sais que Médinoc n'aimera pas mon commentaire ) ne pas faire simplement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
   qsort (tab, 3, sizeof (T-type), compare);

par exemple ?

[Jayceblaster]

voila sur internet j'ai trouvé ce code qui semble mieux adapté a mon probleme...il permet de faire du tri sur un tableau de structure...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
struct fiche
{
   char nom[11];
   char prenom[11];
   int age;
};
 
/* affichage du tableau */
static void aff (struct fiche const *a, size_t n)
{
   size_t i;
   for (i = 0; i < n; i++)
   {
      /* pointeur intermediaire pour alleger l'ecriture */
      struct fiche const *p = a + i;
      printf ("%-10s %-10s %d ans\n", p->nom, p->prenom, p->age);
   }
   printf ("\n");
}
 
/* fonction utilisateur de comparaison fournie a qsort() */
static int compare_prenom (void const *a, void const *b)
{
   /* definir des pointeurs type's et initialise's
      avec les parametres */
   struct fiche const *pa = a;
   struct fiche const *pb = b;
 
   /* evaluer et retourner l'etat de l'evaluation (tri croissant) */
   return strcmp (pa->prenom, pb->prenom);
}
 
/* fonction utilisateur de comparaison fournie a qsort() */
static int compare_age (void const *a, void const *b)
{
   struct fiche const *pa = a;
   struct fiche const *pb = b;
 
   return pa->age - pb->age;
}
 
/* fonction utilisateur de comparaison fournie a qsort() */
static int compare_age_dec (void const *a, void const *b)
{
   struct fiche const *pa = a;
   struct fiche const *pb = b;
 
   return pb->age - pa->age;
}
 
int main (void)
{
/* tableau a trier (tableau de pointeurs sur char const) */
   struct fiche tab[] = {
      {"Simpson", "Homer", 36},
      {"Bouvier", "Marge", 34},
      {"Simpson", "Bart", 10},
      {"Simpson", "Lisa", 8},
      {"Simpson", "Maggie", 2},
   };
 
/* affichage du tableau dans l'etat */
   aff (tab, sizeof tab / sizeof *tab);
 
   qsort (tab, sizeof tab / sizeof *tab, sizeof *tab, compare_prenom);
 
/* affichage du tableau apres le tri */
   aff (tab, sizeof tab / sizeof *tab);
 
   qsort (tab, sizeof tab / sizeof *tab, sizeof *tab, compare_age);
 
/* affichage du tableau apres le tri */
   aff (tab, sizeof tab / sizeof *tab);
 
   qsort (tab, sizeof tab / sizeof *tab, sizeof *tab, compare_age_dec);
 
/* affichage du tableau apres le tri */
   aff (tab, sizeof tab / sizeof *tab);
 
   return 0;
}

on obtient

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
Simpson    Homer      36 ans
Bouvier    Marge      34 ans
Simpson    Bart       10 ans
Simpson    Lisa       8 ans
Simpson    Maggie     2 ans
 
Simpson    Bart       10 ans
Simpson    Homer      36 ans
Simpson    Lisa       8 ans
Simpson    Maggie     2 ans
Bouvier    Marge      34 ans
 
Simpson    Maggie     2 ans
Simpson    Lisa       8 ans
Simpson    Bart       10 ans
Bouvier    Marge      34 ans
Simpson    Homer      36 ans
 
Simpson    Homer      36 ans
Bouvier    Marge      34 ans
Simpson    Bart       10 ans
Simpson    Lisa       8 ans
Simpson    Maggie     2 ans

ca marche sous window (compilateur Dev C++) mais sous linux ca ne marche plus (oui je dev sous linux)...

[souviron34]

Primo je ne vois pas l'utilité de faire 3 tris qui s'écrasent les uns les autres... (et si c'est pour tester il te manque le nom )

d'autre part, il me semble que sur *nux, qsort attend un retour de -1, 0, ou 1..

[Jayceblaster]

je ne comprend pas la particularité que tu mentionne sur l'utilisation du Qsort sous linux

[souviron34]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
static int compare_age (void const *a, void const *b)
{
   struct fiche const *pa = a;
   struct fiche const *pb = b;
 
  if ( pa->age - pb->age < 0 )
     return -1 ;
  else
  if ( pa->age - pb->age >0 )
     return 1 ;
  else
   return 0;
}

[Médinoc]

@souviron: Là encore, ce serait un manquement au standard.

Quant aux tris, ils seraient inutiles s'il n'y avait pas d'affichage entre.
Je tiens à rappeler à cet effet que QuickSort n'est pas un algorithme de tri "stable" : Si plusieurs éléments ont la même clé, leur ordre ne sera pas conservé.

Cette différence est bien visible en C++, où deux fonctions de tri différentes sont proposées: sort() et stable_sort().
Hélas, je ne connais aucun équivalent à stable_sort() dans la bibliothèque standard C.

[souviron34]

mais sous linux ca ne marche plus (oui je dev sous linux)...

peux-tu préciser ce qui ne marche pas stp ?

[orfix]

Eh non...

Il y a un do .. whle i >= 0

Donc si on est à i = 0, on fait bien i-1, et le do ne se fait pas...

Je n'ai pas vraiment compris

(enfin, je pense, je fais toujours plutôt à l'envers while (i >= 0), sans le do..)

Là je suis d'accord avec un while tout court le i-- serais bon

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
		if( tab[i]==NULL )
		{	/* Erreur d'allocation on libere tout ...*/
                        i-- ;
			while(i>=0)
			{
				free( tab[i] );
				tab[i]=NULL;
				i--;
			}
		}

[souviron34]

Je n'ai pas vraiment compris

ce que je veux dire c'est que je pense qu'un compilateur, voyant do...while , fait la même chose que si il y avait juste while.

Donc mon algo est valide...

[diogene]

ce que je veux dire c'est que je pense qu'un compilateur, voyant do...while , fait la même chose que si il y avait juste while.

J'espère que non : le test dans un while est fait en tête et dans do...while en queue. Autrement dit le code dans un do...while est toujours exécuté au moins une fois alors que celui d'un while peut ne pas l'être du tout.