Tri sélectif de nombres

Bonjour, je recherche une méthode de tri efficace...j'ai beaucoup cherché mais je n'ai rien trouvé de probant...je ne sais pas s'il existe une astuce simple pour trier des nombres dans un ordre croissant ou décroissant.
Considérant la classe Nombre

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

class Nombre { // Variables d'instance : public int nombre; // Constructeur : public Nombre(int nombre) { setNombre(nombre); }   protected Nombre setNombre(int nombre) { this.nombre = nombre; return this; }   public int getNombre() { return this.nombre; } }

---

Code:

---

1 2 3 4 5 6

LinkedList nbre = new LinkedList(); nbre.add(new Nombre(11)); nbre.add(new Nombre(2)); nbre.add(new Nombre(29)); nbre.add(new Nombre(199)); nbre.add(new Nombre(3));

---

Ensuite je place dans une LinkedList, cinq nouvelles instances de la classe Nombre et je voudrais les trier par ordre décroissant dans une nouvelle LinkedList.

Quelqu'un a t il une astuce simple pour arriver parce que je tourne en rond et je n'ai rien obtenu de très bon pour le moment...:(

Merchhi...:mrgreen:

Code:

---

1 2 3

LinkedList nbre = new LinkedList(); Collections.sort(nbre);

---

Sinon, si tu veux implémenter toi-même les algo, cherche du côté du tri-fusion ou du tri par insertion ou Quicksort avec :google: (mais il va falloir passer par un tableau pour trier les éléments --> plus efficace)

[Edit :] bien sûr, il faut que tes Nombres soit comparables pour que sort fonctionne :

Citation:

---

Javadoc a dit :
All elements in the list must implement the Comparable interface. Furthermore, all elements in the list must be mutually comparable (that is, e1.compareTo(e2) must not throw a ClassCastException for any elements e1 and e2 in the list).

---

;) Thanks...je vais regarder cela de plus près...

8O Euh pardonne moi si je dis une bêtise mais il est préférable que je réimplémente la méthode compareTo() alors pour que mes objets soient comparables...en gros faire de l'overloading? Sinon je ne pense pas que la méthode compareTo() de java donne un résultat significatif?

Citation:

---

en gros faire de l'overloading?

---

en gros, juste implémenter la méthode de l'Interface Comparable (avec Nombre implements Comparable) :mouarf:


au fait ,
tu entends quoi par

Citation:

---

la méthode compareTo() de java...

---

? :?

Il faut que ta classe Nombre implement Comparable et il faut redéfinir ensuite la méthode compareTo() afin de comparer deux Nombres entre eux.

En fait pour utiliser la méthode Collection.sort(maCollection); je demandais si je devais réimplémenter la méthode compareTo() de Java...je pensais que je devais réimplémenter la méthode compareTo() pour qu'elle puisse comparer mes objets Nombre et que cette méthode était incluse dans l'implémentation de la méthode Collections.sort(Collection newOne)...

Citation:

---

en gros, juste implémenter la méthode de l'Interface Comparable (avec Nombre implements Comparable)

---

C'est à dire? :? Je débute donc évite d'utiliser des mots compliqués :aie:

EDIT : ah oui donc je dois réimplémenter compareTo() dans me classe Nombre pour que la nouvelle implémentation de celle ci prime sur celle de Java?

Bonjour,

Je n'ai même pas lu ton message, je ne te donnerais donc pas de solution.

Je me contente de réagir au titre:

Citation:

---

Envoyé par Sylvester

Tri sélectif de nombres

---

Par définition, un tri est sélectif.

Je pense que tu y est dans l'idée...

ce que contient ta collection doit être en mesure de se placer (de s'ordonner dans ton cas) par rapport à d'autres objets. Il doit implémenter les méthode de l'interface Comparable et doit se présenter ainsi :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

class Nombre implements Comparable{ // Variables d'instance : public int nombre; // Constructeur : public Nombre(int nombre) { setNombre(nombre); }   protected Nombre setNombre(int nombre) { this.nombre = nombre; return this; }   public int getNombre() { return this.nombre; } }

---

Tel qu'écrit au dessus, le code n'est pas compilable, car le contrat qui lit Nombre à l'interface Comparable n'est pas rempli (Il n'y a pas de méthode compareTo())
Tu dois donc ajouter cette méthode en écrivant :

Code:

---

1 2 3 4 5

public int compareTo(Object arg0) { //effet par défaut, il te faut écrire ce que fait la méthode return 0; }

---

Voici ce que dois retourner ta méthode :

Citation:

---

compareTo
Javadoc a dit :
public int compareTo(Object o)
Compares this object with the specified object for order. Returns a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object.

---

salut,

je vois que tout le monde tourne autour du pot sans donner la ligne de code qui fait marcher :P:
Voici ce qu'il faut faire:

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

class Nombre implements Comparable<Nombre> { // Variables d'instance : public int nombre; // Constructeur : public Nombre(int nombre) { setNombre(nombre); }   protected Nombre setNombre(int nombre) { this.nombre = nombre; return this; }   public int getNombre() { return this.nombre; }   public int compareTo(Nombre anotherNombre) { if (this.nombre > anotherNombre.getNombre()) return 1; if (this.nombre < anotherNombre.getNombre()) return -1; if (this.nombre == anotherNombre.getNombre()) return 0; } }

---

J'ai pas teste ce code mais je crois que ca marche a vue de nez.
Ceci dit, je trouve que tout ca n'est pas super elegant : il existe deja la classe Integer par exemple qui fait du wrapping d'entier et qui implemente deja Comparable et tout, et qui marchera donc directement pour ton histoire de tri.
Voila, j'espere que j'ai ete clair.

yelbied

Salut,

sinon :
:tutoriel:

^^

Fred

Citation:

---

je vois que tout le monde tourne autour du pot sans donner la ligne de code qui fait marcher :
Voici ce qu'il faut faire:

---

et la pédagogie, alors ? :mrgreen: