Tri sélectif de nombres

**Sylvester** · 21/06/2006, 13h07

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 :

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
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 :

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

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...

**dazz_x** · 21/06/2006, 13h15

Code :

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

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

(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 :

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).

**Sylvester** · 21/06/2006, 13h20

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

**Sylvester** · 21/06/2006, 13h28

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?

**dazz_x** · 21/06/2006, 13h40

en gros faire de l'overloading?

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

au fait ,
tu entends quoi par

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

?

**spoutyoyo** · 21/06/2006, 13h42

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.

**Sylvester** · 21/06/2006, 13h51

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)...

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

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?

**thewho** · 21/06/2006, 14h00

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:

Envoyé par Sylvester

Tri sélectif de nombres

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

**dazz_x** · 21/06/2006, 14h06

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 :

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
 
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 :

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

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 :

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.

**yelbied** · 21/06/2006, 15h08

salut,

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:

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
 
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