Tri d'une liste

Version imprimable

Tri d'une liste

bonsoir
j'ai une liste qui contient dans chaque case un mot avec son score voilà un exemple

arbre 0.56887
deee 12.589
cfdss 3.589
dett 6.589155
dfrzz 5.69875

je voulai trier les lignes dans l'ordre décroissant
je voulais que ma liste soit comme ça:

deee 12.589
dett 6.589155
dfrzz 5.69875
cfdss 3.589
arbre 0.56887

voilà le code que j'ai essayé mais ça donne rien :(

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
for ( i=0;i<taille1;i++)
             {
                 for (j=1;i <taille1-1;j=j--)
 
                 {
                            c = list4[j].lastIndexOf(" ");
 
                        if (Float.valueOf(list4[j-1].substring(c))>(Float.valueOf(list4[j].substring(c))))
                            {
                                 a= list4[j-1];
                                list4[j-1]= list4[j];
                                 list4[j]=a;
 
 
 
                            }
                    //    j=j-2;
 
                 }
             }

pourriez vous m'aidez svp

07/02/2014, 20h22
joel.drigo
Salut,

Au lieu de chercher à reconcevoir un algorihme de tri à zéro, avec tout ce que ça comporte comme maladresses et risques d'erreur, autant utiliser les fonctionnalités de tri disponibles dans le JDK.

Tu crées une classe qui a 2 attributs : le nom (une String) et la valeur (un Float). Tu crées une liste dans laquelle tu vas ajouter des instances de cette classe, obtenues par parsing de tes lignes (avec un split(" ") pour séparer les 2 parties, et un une conversion String to Float, par Float.valueOf().

Ensuite, la méthode sort de la classe Collections, qui va te permettre de trier ta liste, propose 2 alternatives :
- soit tu implémentes Comparable<Float> sur ta classe, ce qui consiste à implémenter compareTo() : facile puisque Float est comparable (c'est pour ça que j'ai dit Float et pas float, pour te simplifier la tâche)
- soit tu implémentes un Comparator<Float>, et sa méthode compare, qui est aussi facile que le compareTo() de Comparable.
08/02/2014, 14h29
mimihh

quand je fait un breakpoint pour cette ligne

Code:

c = list4[j].lastIndexOf(" ");

elle reste toujours rouge lors de débogage je sais pas pourquoi donc le tri ne peut pas s'effectuer :cry:
pourriez vous me dire les causes?
Merci d'avance.
08/02/2014, 14h45
joel.drigo

Salut,

Ça ne veut rien dire qu'une ligne reste en rouge : s'il y a une erreur, il y a un intitulé d'erreur, qui permet de comprendre le problème. Quel est donc cet intitulé ?
08/02/2014, 14h54
joel.drigo
En substance, cette ligne :

Code:

for (j=1;i <taille1-1;j=j--)

fait une boucle infinie, pour 2 raisons :
- j=j-- est équivalent à j=j, à cause du fonctionnement particulier de l'opérateur unaire, et de principe de l'affectation : le résultat est j, on décrémente j dans le calcul, puis le résultat (toujours j avant la décrémentation) à j ;
- la condition d'arrêt i<taille1 teste i, qui ne varie pas dans la boucle.
08/02/2014, 14h55
mimihh

si cette ligne reste rouge après le débogage cela veut dire que le programme saute cette ligne et es lignes qui la suivent lors de l’exécution.
En plus il y a pas d’erreurs dans mon code :BUILD SUCCESSFUL (total time: 0 seconds)
mais le problème c'est qu'il saute un nombre d'instruction lors de l’exécution puisqu'elles restent rouge après le débogage
08/02/2014, 15h02
mimihh

j'ai changé cette ligne:

Code:

for (j=1;j <taille1-1;j=j--)

et rien n'a changé toujours le même problème
08/02/2014, 15h03
joel.drigo

Citation:

Envoyé par mimihh

si cette ligne reste rouge après le débogage cela veut dire que le programme saute cette ligne et es lignes qui la précédent lors de l’exécution.

Aucune ligne n'est jamais "sautée" lors de l'exécution. Des séquences de code peuvent être non exécutées si elles sont soumises a des des conditions évaluées comme fausses, ou d'autres types de structures. Je ne sais pas quel IDE tu utilises, et je ne comprends pas la signification de ce surlignement en rouge de lignes. Soit des lignes ne peuvent pas être exécutées (comme des lignes après un return dans une méthode) et le code ne compile pas, soit ça compile, et toutes lignes est susceptible d'être exécutée selon la valeur du contexte et des structures (conditions, boucles, etc...) appliquées à ce contexte.

Citation:

Envoyé par mimihh

En plus il y a pas d’erreurs dans mon code :BUILD SUCCESSFUL (total time: 0 seconds)

Le fait de ne pas avoir d'erreurs à la compilation ne signifie pas qu'il n'y ait pas d'erreur à l'exécution.
08/02/2014, 15h05
joel.drigo

Citation:

Envoyé par mimihh

j'ai changé cette ligne:

Code:

for (j=1;j <taille1-1;j=j--)

et rien n'a changé toujours le même problème

Normal. Comme je le disais, j=j-- ne fait pas varier j, et la boucle est donc infinie.

EDIT : je ne dis pas que la correction fera fonctionner ton algorithme, mais empêchera la boucle d'être infinie. Puisque que tu persistes dans l'élaboration d'un algorithme de tri personnel, plutôt que de suivre les indications que je t'ai données sur Collections.sort(), je suppose que le but est d'élaborer l'algorithme de tri. Je te laisse donc découvrir les autres problèmes et les résoudre par toi-même.

Merci pour ton aide. En fait, je suis débutante en java et j'ai pas une idée sur la méthode sort de la classe Collections comme tu m'a proposé c'est pour ça que j'ai choisi de continuer avec mon algorithme.
Sinon j'ai essayer de corriger mon code mais toujours le même problème :(

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
  for (int i=taille1;i <1;i--)
 
             {
                for (int j=2;j<i;j++)
 
                 {     
                            c = list4[j].lastIndexOf(" ");
                           if (Float.valueOf(list4[j-1].substring(c))>(Float.valueOf(list4[j].substring(c))))
                            {
                                 a= list4[j-1];
                                list4[j-1]= list4[j];
                                 list4[j]=a;
 
                            }
 
 
                }
             }

quelqu'un peut m'aider à détecter le problème

Voilà les exemples à partir des méthodes de tri du JDK.

Tri d'un tableau

Code:

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
public class DemoTriTableau {
 
    public static void main(String[] args) {
 
        String[] data = new String[] { "arbre 0.56887", "deee 12.589",
                "cfdss 3.589", "dett 6.589155", "dfrzz 5.69875" };
 
        afficher(data);
        trier(data);
 
        System.out.println();
        System.out.println("Données triées :");
        afficher(data);
 
    }
 
    private static void trier(String[] data) {
 
        // pour éviter de parser et de convertir le nombre à chaque fois, on va
        // convertir les data une fois (mais on pourrait le faire directement 
        // dans la méthode compare() du Comparator (ce qui pourrait nous permettre de ne pas passer par un tableau intermédiaire)
        class Data {
            public final String ligne;
            public final Float valeur;
 
            public Data(String ligne) {
                // on stocke la ligne pour restituer la liste à la fin
                this.ligne = ligne;
                // on convertit le nombre qui se trouve en seconde position dans une ligne où les informations sont séparés par une espace
                this.valeur = Float.valueOf(ligne.split(" ")[1]);
            }
        }
 
        // on créé un tableau avec nos informations adaptées au tri
        Data[] tableauATrier = new Data[data.length];
        for(int i=0; i<data.length; i++) {
            tableauATrier[i]=new Data(data[i]);
        }
 
        // on fait le tri
        Arrays.sort(tableauATrier, new Comparator<Data>() {
 
            @Override
            public int compare(Data d1, Data d2) {
                // l'ordre de tri correspond à l'ordre des valeurs 
                // le - est parce que le tri est décroissant
                return -d1.valeur.compareTo(d2.valeur);
            }
 
        });
 
        // on remet à jour le tableau
        for(int i=0; i<data.length; i++) {
            data[i]=tableauATrier[i].ligne;
        }
 
    }
 
    private static void afficher(String[] data) {
        for (String ligne : data) {
            System.out.println(ligne);
        }
    }
 
}

Tri d'une liste (ArrayList) :

Code:

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
public class DemoTriList {
 
    public static void main(String[] args) {
 
        List<String> data = new ArrayList<>(Arrays.asList("arbre 0.56887", "deee 12.589",
                "cfdss 3.589", "dett 6.589155", "dfrzz 5.69875" ));
 
        afficher(data);
        trier(data);
 
        System.out.println();
        System.out.println("Données triées :");
        afficher(data);
 
    }
 
    private static void trier(List<String> data) {
 
        // pour éviter de parser et de convertir le nombre à chaque fois, on va
        // convertir les data une fois (mais on pourrait le faire directement
        // dans la méthode compare du Comparator (ce qui pourrait nous permettre de ne pas passer par une liste intermédiaire)
        class Data {
            public final String ligne;
            public final Float valeur;
 
            public Data(String ligne) {
                // on stocke la ligne pour restituer la liste à la fin
                this.ligne = ligne;
                // on convertit le nombre qui se trouve en seconde position dans une ligne où les informations sont séparés par une espace
                this.valeur = Float.valueOf(ligne.split(" ")[1]);
            }
        }
 
        // on créé une liste avec nos informations adaptées au tri
        List<Data> listeATrier = new ArrayList<>(data.size());
        for(String ligne : data) {
            listeATrier.add(new Data(ligne));
        }
 
        // on fait le tri
        Collections.sort(listeATrier, new Comparator<Data>() {
 
            @Override
            public int compare(Data d1, Data d2) {
                // l'ordre de tri correspond à l'ordre des valeurs 
                // le - est parce que le tri est décroissant
                return -d1.valeur.compareTo(d2.valeur);
            }
 
        });
 
        // on remet à jour la liste
        data.clear();
        for(Data ligne : listeATrier) {
            data.add(ligne.ligne);
        }
 
    }
 
    private static void afficher(List<String> data) {
        for (String ligne : data) {
            System.out.println(ligne);
        }
    }
 
}

09/02/2014, 22h59
mimihh

Merci :)