Discussion :

[thuglife]

Bonjour,

Voici ce que j'aimerais faire, j'ai un tableau avec 5 colonnes et n lignes (l'utilisateur entre le nombre de lignes). j'aimerais pouvoir trier ce tableau par ordre décroissant avec pour priorité la 1ère colonne, puis la 2ème etc etc. c'est à dire que si dans la première colonne j'ai 3 valeurs identiques, le tri entre les 3 se fera sur la 2ème colonne et ainsi de suite.

Je ne sais pas du tout par quoi commencer, est-ce que je déclare une structure de ligne pour mon tableau contenant mes 5 colonnes ?
est-ce qu'il est possible de réaliser ce genre de tri ?

je sèche totalement, je ne cherche pas le programme entier, je cherche simplement à démarrer de la bonne façon.

Une idée ?

[Obsidian]

Bonjour,

C'est un cas de figure typique des bases de données. Tu te trouves dans une situation où chaque ligne forme un n-uplet, ou « t-uple » chez les anglo-saxons, et donc concrètement un enregistrement indivisible.

Si tu n'as pas envie de réécrire l'algorithme de tri toi-même, tu peux t'appuyer sur qsort(). Le plus simple consiste effectivement à déclarer une structure pour tes enregistrements. Ainsi, ton tableau sera unidimensionnel et le parcourir sera trivial. Tu n'auras plus, ensuite, qu'à écrire une fonction prenant en argument deux pointeurs distincts vers cette structure et comparer leurs éléments dans l'ordre qui t'intéresse. Tu passes cette fonction à qsort() et ton tableau sera trié comme tu le souhaites.

[Trap D]

Rien de tel qu'un petit exemple pour comprendre ce que veut dire Obsidian !

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
// on aura ici un tableau de deux valeurs de type chaîne de caractères
typedef struct my_struct
{
    char *nom;
    char *prenom;
} my_struct;
 
// le tableau à trier
my_struct tab[] =
{
    {
        "blanc", "michel"
    },
    {
        "simon", "michel"
    },
    {
        "blanc", "gerard"
    }
};
 
// la fonction de tri
int my_comp(void *arg1, void *arg2)
{
    // on caste d'abord les arguments de la fonction dans le bon type
    my_struct *premier = (my_struct *) arg1;
    my_struct *second = (my_struct *) arg2;
 
    // je compare d'abord les noms
    int ret = strcmp(premier->nom, second->nom);
 
    // si ce sont les mêmes, je compare les prénoms
    if (ret == 0)
        ret = strcmp(premier->prenom, second->prenom);
 
    // je retourne le resultat de la comparaison
    return ret;
}
 
void affiche(my_struct *tab, size_t nbElem)
{
    size_t n;
 
    for(n = 0; n < nbElem; n++)
        printf("%s %s\n", tab[n].nom, tab[n].prenom);
 
    puts("");
}
 
// dans le prog, j'affiche le tableau avant et après le tri
int main(void)
{
    affiche(tab, sizeof tab / sizeof *tab);
 
    // la fonction de tri a besoin de 4 arguments
    // le nom du tableau (logique)
    // sa taille en nombre d'éléments
    // la taille de chaque éléments du tableau
    // le nom de la fonction de tri
    qsort(tab, sizeof tab / sizeof *tab, sizeof *tab, my_comp);
 
    affiche(tab, sizeof tab / sizeof *tab);
 
    return 0;
}

[dinobogan]

D'un point de vue technique, tu as la réponse.
Maintenant, d'un point de vue algorithmique, il est possible d'utiliser un tri stable et de faire un tri décroissant pour chaque clé, de la moins importante à la plus importante.
Un tri est dit stable lorsque deux éléments égaux dans la liste initiale ne sont pas inversés après le tri. L'algorithme du quicksort n'est pas stable.