Discussion :

[endhumans]

Bonjour,
Je souhaite mélanger des nombres dans un tableau donné. Par exemple : [1,2,3,4,5,6] que ça me donne aléatoirement quelque chose comme [6,1,3,4,2,5]. Ensuite je voudrais prendre les nombres paires et les mettre dans un autre tableau, ainsi que les nombres impaires dans un troisième tableau.
Merci d'avance de votre aide.

[tchize_]

Pour la mise en désordre, abuse de la fonction de tri (sort) :p

Code :

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

1
2
3
4
5
6
Arrays.sort(tableau,new Comparator<type>(){
 Random r = new Random();
 public int compare(type o1, type o2){
      return r.nextInt();
 }
});

avec type le type de ton tableau


Pour séparer en deux tableau -> Faut y aller à la main ^^

[Uther]

C'est pas risqué cà?

Y'a pas de risque que le tri s'éternise ou ne soit pas si aléatoire que ça étant donné que des règles de base de l'arithmétique sont violées?
Par exemple on peut avoir a<b et b<c mais a>c

[wax78]

un petit

Code :

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

Collections.shuffle();

n'irait pas ?

[tchize_]

@wax78: oui, et ce serait idéal

@uther: non, car l'algorithme est un merge sort, ca signifie qu'à chaque récursion il va séparer son set d'élément en deux sous éléments, donc va avancer. Mais de fait, c'est de l'abusage pour le fun ^^

[Uther]

La spec garantit que l'on fait un merge sort?
Sinon, ca pourrait être faut suivant l'implémentation de la JVM.

edit après vérification dans la javadoc:

For example, the algorithm used by sort(Object[]) does not have to be a mergesort, but it does have to be stable.

[tchize_]

j'ai ca dans les specs, mais bon, de toutes facons on est d'accord, c'est pas la meilleure solution:

The sorting algorithm is a modified mergesort (in which the merge is omitted if the highest element in the low sublist is less than the lowest element in the high sublist). This algorithm offers guaranteed n*log(n) performance.

Et puis, ca ne peut que finir, pour ne pas finir, il faudrait que le random aille constament à l'inverse de l'avancement de l'algo, ce qui est improbable