Discussion :

[ensi2007]

J'ai une matrice de 2 lignes et plusieurs colonnes (plus d'une centaine)

J'aimerais trier la matrice en fonction des valeurs de la première ligne de telle façon que les valeurs de la deuxième ligne suivent lors des permutations:

Exemple:

2 3 5 4 1

a b c d e

Après tri:

1 2 3 4 5

e a b d c

Merci!

[tromaltsec]

bonjour une solution possible (pas optimisée) doit ressembler à ça:

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
 
        int[][] matrice={{1,2,3,4,5,6,7,8,9,0},{11,12,13,14,15,16,17,18,19,10}};
 
        for (int i = 0; i < matrice[0].length; i++) {
            for (int j = i+1; j < matrice[0].length; j++) {
                if(matrice[0][i]>matrice[0][j]){
                    int var=matrice[0][i];
                    matrice[0][i]=matrice[0][j];
                    matrice[0][j]=var;
                    var=matrice[1][i];
                    matrice[1][i]=matrice[1][j];
                    matrice[1][j]=var;
                }
            }
        }
                for (int i = 0; i < 2; i++) {
            for (int j = 0; j < matrice[i].length; j++) {
                System.out.println(matrice[i][j]+" ");
            }
                    System.out.println("");
        }

l'idée est de faire la meme action à la ligne en dessous que celle d'au dessus. Sinon tu passes par un tableau de Hashtable dont ta clé est l'élément à trier.

Bon courage

[Fmunch]

Il existe des méthodes de tri plus rapide que celle proposé par tromaltsec, ça méthode nécessite n² opérations, il existe des méthode qui n'en nécessitent que n log n. Pour 100 ou même 1000 éléments à trier ça méthode conviendra. Pour un nombre plus important je te préconise une méthode de tri rapide.

• soit tu l'implémente
• soit tu utilise celle fournis par la librairie standard java

Dans le second cas tu peut utiliser une TreeMap : les éléments y seront trier par leurs clés, ou encore crée ton propre type, que tu tri ensuite. La première méthode est la plus flexible : tu peut toujours réaliser des rajouts, la seconde te fournis directement une liste, et est plus rapide au niveau de l'utilisation des éléments une fois trié.

[ensi2007]

Pour le moment je suis en moyenne à une centaine d'éléments donc le code de tromaltsec me va parfaitement!! Mais ej prends ta proposition en considération Fmunch

Merci à vous deux!!

[Fmunch]

Enfin conserver les deux entités séparé me semble vraiment pas terrible, tu n'utilise pas d'objet du tous, le jours où tu aura une colonne supplémentaire, tu pourras à nouveau modifier son code, cela me parait compliqué. Voici un petit code de 45 lignes qui te fait cela proprement ( on pourrait faire plus général que avec des nombres et des chaînes de caractères )

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
class Entree implements Comparable<Entree>
{
  int k;
  String v;
  Entree(int k,String v){
    this.k = k;
    this.v = v;
  }
  int getK() { return k;}
  String getV() { return v;}
  public int compareTo(Entree e2)
  {
    return k-e2.k;
  }
 
  public String toString()
  {
    return "[ "+k+" => "+v+" ]";
  }
  public static Entree[] creerEntrees(int[] arr1, String[] arr2)
  {
    int min = Math.min(arr1.length,arr2.length);
    Entree[] res = new Entree[min];
    for(int i = 0 ; i < min ; i++)
    {
      res[i] = new Entree(arr1[i],arr2[i]);
    }
    return res;
  }
}
 
public class TestEntreeSort
{
  public static void main(String[] args)
  {
    int[] arr1 = {2,3,5,4,1};
    String[] arr2 = {"a","b","c","d","e"};
    Entree[] entrees = Entree.creerEntrees(arr1,arr2);
    System.out.println(java.util.Arrays.toString(entrees));
    java.util.Arrays.sort(entrees);
    System.out.println(java.util.Arrays.toString(entrees));  
  }
}