Trier un tableau en java

Version imprimable

Bonjour à toutes et à tous,
je crée une classe utilitaire pour gérer les tableaux à une dimension.
L'une des méthodes de cette classe a pour but de trier un tableau dans l'ordre croissant :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 public static int [] croissant(int t[] ) { int aide; int [] temp=new int[t.length]; temp=t; for(int i=0;i<t.length;i++) { if(temp[i] > temp[i++] ) { aide=temp[i++]; temp[i++]=temp[i]; temp[i]=aide; } } return temp; }
L'appel de cette méthode ne tri pas le tableau concerné.

Cordialement.

Essaie ce petit code

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
 
class ForumDeveloppez{
    public static void main(String [] args){
        int t[] = {5, 55, 1, 558, 14, 12};
        int res[] = triCroissant(t);
        for(int j : res){
            System.out.print(j +" ");
        }
    }
    public static int [] triCroissant(int t []){
        int n = t.length, i = 0, aux = 0;
        boolean trie = true;
        while(trie){
            trie = false;
            i = 0;
            while(i < n - 1){
                if(t[i] > t[i + 1]){
                    trie = true;
                    aux = t[i];
                    t[i] = t[i + 1];
                    t[i + 1] = aux;
                }
                i++;
            }
            n--;
        }
        return t;
    }
}

04/02/2018, 21h27
Glob

Hello,

et tu as même un tri déjà tout fait:

Code:

java.util.Arrays.sort(int[])

:roll:
06/02/2018, 01h16
gautier1er
merci :D
Code:

1 2 3 4 5 6 7 public static int [] croissant(int t[] ) { java.util.Arrays.sort(t); return t; }
la méthode fonctionne bien maintenant.
J'aimerai aussi que tu me donne l'inverse , c'est à dire le tri décroissant

merci d'avance

Salut,

Pour répondre à la question initiale, le premier problème dans ton code se situe au niveau de l'emploi de i++. Cet opérateur (++) modifie (incrémente) la valeur de la variable à laquelle il est appliqué, mais la valeur utilisée est celle avant l'incrémentation. Donc quand tu fais if(temp[i] > temp[i++], çà correspond à faire :
Code:

1 2 3 if ( temp[i]>temp[i] ) { // ce qui est toujours faux i=i+1; // si cette instruction était exécutée, tu avancerais d'un coup dans le tableau, donc tout le reste du code dans le bloc serait appliqué au mauvais index dans le tableau }
Un autre problème est que tu ne fais qu'une passe : si une valeur n'est pas à sa place, ça va fonctionner, mais dès qu'il y'en a deux, ça ne triera que la plus grande et laissera les autres. Il suffit donc de recommencer le tri autant de fois que nécessaire. Quand sait-on qu'il faut s'arrêter : lorsqu'au cours d'une passe, on n'a pas fait d'échange. Une solution pour optimiser est de considérer que comme on pousse la valeur la plus grande à la fin, il suffit que la passe suivante ne traite pas la valeur à la fin, puisqu'on sait qu'elle est déjà trier : à chaque fois, on trie un tableau un peu plus petit, jusqu'à ce qu'on ait plus qu'un tableau de taille 0 à trier et on donc on s'arrête.
Autre problème : la boucle for(int i=0;i<t.length;i++). Comme tu compares chaque case à sa suivante, il faut penser que lorsque tu vas comparer la dernière case, ça va planter puisque tu tenteras de comparer celle-ci avec une case en dehors du tableau, qui n'existe pas donc.
Enfin, tu ne trie pas le tableau passé en paramètre, mais un autre tableau (temp) qui ne contient que des 0. Il ne sert à rien ce tableau, sauf si tu ne veux pas modifier le tableau original : dans ce cas, il faut au moins copier le tableau passé en paramètre dans temp. Une solution pourrait être d'en profiter pour trier ou prétrier lors de la copie.

Pour répondre à la seconde question, il n'y a pas de méthode toute faite pour trier directement un tableau de int dans le sens décroissant. On peut le faire simplement pour des tableaux d'objets (Voir JavaDoc : tri avec comparateur, tri parallèle avec comparateur et comparateur qui inverse l'ordre.

Pour le faire, il te suffit d'utiliser Arrays.sort() puis d'inverser le tableau. En corrigeant les problèmes de ton code initial, en revanche, ce sera très simple d'inverser l'ordre.

Il y a bien une solution pour le faire avec un stream, mais c'est un peu overkill (et moins rapide et plus consommateur de mémoire) : int[] descendingArray = Arrays.stream(array).mapToObj(Integer::new).sorted(Comparator.reverseOrder()).mapToInt(Integer::intValue).toArray();

06/02/2018, 17h18
professeur shadoko
Citation:
Envoyé par gautier1er

merci :D

Code:

1 2 3 4 5 6 7 public static int [] croissant(int t[] ) { java.util.Arrays.sort(t); return t; }

la méthode fonctionne bien maintenant.
J'aimerai aussi que tu me donne l'inverse , c'est à dire le tri décroissant

merci d'avance
petite note: c'est plutôt une bonne idée d'avoir une méthode qui prenne un paramètre et qui rende un tableau trié en résultat.
Dans certains cas , pour vraiment se conformer à ce principe et pour ne pas avoir d'effet de bord, ce serait encore mieux de faire un clone du tableau paramètre, de trier ce clone et de le rendre en résultat. Certes on peut considérer que c'est du gâchis de dupliquer le tableau mais c'est plus propre dans une vision purement fonctionnelle.

j'ai repris ma méthode pour trier un tableau dans l'ordre croissant et j'ai aussi ajouter la méthode qui tri dans l'ordre décroissant. Ces deux méthodes marchent bien .
la méthode crois

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 public static int [] crois(int t[] )
 {
     int aide=0;
 
      for(int i=0;i<t.length-1;i++)
      {
         for(int j=i+1;j<t.length;j++)
         {
           if(t[i]>t[j])
            {
              aide=t[i];
              t[i]=t[j];
              t[j]=aide; 
            }
         }
      }
 
 
     return t;
 }

la méthode decrois

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
 public static int [] decrois(int t[] )
 {
     int aide=0;
 
      for(int i=0;i<t.length-1;i++)
      {
         for(int j=i+1;j<t.length;j++)
         {
           if(t[i]<t[j])
            {
              aide=t[i];
              t[i]=t[j];
              t[j]=aide; 
            }
         }
      }
 
 
     return t;
 }

D'après le professeur shadoko
je ferai un clone du tableau passé en paramètre après vos avis sur ces deux méthodes

08/02/2018, 10h43
professeur shadoko

Citation:

Envoyé par gautier1er

je ferai un clone du tableau passé en paramètre après vos avis sur ces deux méthodes

tu pourras ainsi avoir 3 tableaux: le tableau d'origine, celui trié par ordre croissant et celui trié par ordre décroissant.
(après on peut aussi argumenter comme quoi il est plus facile de faire le tableau décroissant à partir du tableau croissant ... mais bon)
10/02/2018, 11h05
Taserface

Bonjour,
j'adhère à l'idée de @Professeur Shadako il vaut mieux dans la majorité des cas quand on utilise des objets de faire un clone des données sur lesquelles on travaille après c'est un point de vu mais aussi cela permet de bénéficier des méthodes et autres joyaux objets imagines que tu as un String à trier et qu'on te demande de ne pas utilisé les tableaux juste des boucles.

voici les méthodes avec utilisation de clonage:
méthode crois

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 public static int [] crois(int t[] )
 {
     int aide=0;
     int tab[]=new int[t.length];
     tab=t.clone();
      for(int i=0;i<tab.length-1;i++)
      {
         for(int j=i+1;j<tab.length;j++)
         {
           if(tab[i]>tab[j])
            {
              aide=tab[i];
              tab[i]=tab[j];
              tab[j]=aide; 
            }
         }
      }
 
 
     return tab;
 }

méthode decrois
le tableau passé en paramètre de la méthode decrois est un tableau trié préalablement dans l'ordre croissant.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 public static int [] decrois(int t[])
  {
      int aide;
    int [] tab=new int[t.length];
    tab=t.clone();
    int j=tab.length;
 
    for(int i=0;i<j;i++)
    {
        --j; 
        aide=tab[i];
        tab[i]=tab[j];
        tab[j]=aide;
 
    }
 
    return tab;  
  }

23/02/2018, 23h46
gautier1er

Merci à tous ceux qui ont participé à ce sujet.