studio - ordenar un array java

¿Cuál es el orden de clasificación de las colecciones de Java(lista, comparador)? ¿Pequeño a grande o grande a pequeño?

Question

Al parecer, no está documentado o me lo perdí.

Here está el enlace a la documentación y debajo el texto como una imagen:

EDITAR (17/5): Creo que muchos confunden esta pregunta para ser una pregunta comparativa. No lo es. El comparador compara entre 2 elementos. Según esa comparación, la lista se ordenó. ¿Cómo? ¿Ascendiendo o descendiendo?

Refinaré / simplificaré la pregunta aún más: si el comparador decide que el elemento A es más pequeño que el elemento B. En la lista ordenada , ¿estará el elemento A en un índice más pequeño que el elemento B?

Answer 1

De acuerdo con la documentación https://docs.oracle.com/javase/7/docs/api/java/util/Collections.html#sort(java.util.List,%20java.util.Comparator , la implementación de clasificación para colecciones .sort (list, comparator) es mergeSort.

Dado que el resultado producido por mergeSort es ascendente ( https://en.wikipedia.org/wiki/Merge_sort ), el orden de clasificación de Collections.sort (lista, comparador) es ascendente.

Es decir, si el comparador decide que el elemento A es más pequeño que el elemento B. En la lista ordenada, el elemento A se ubicará en un índice más pequeño que el elemento B.

Answer 2

El orden de clasificación siempre es ascendente , donde el Comparador define qué elementos son más grandes que otros.

De la documentación de Collections.sort (Lista <T> lista, Comparador <? Super T> c) :

Ordena la lista especificada según el orden inducido por el comparador especificado.

De la documentación de Comparator.compare(T,T) :

Compara sus dos argumentos por orden. Devuelve un entero negativo, cero o un entero positivo ya que el primer argumento es menor que, igual o mayor que el segundo.

Answer 3

La documentación del método Comparator.compareTo(o1, o2) dice

Compara sus dos argumentos por orden. Devuelve un entero negativo, cero o un entero positivo ya que el primer argumento es menor que, igual o mayor que el segundo.

Por lo tanto, si desea ordenar el orden natural, que es de pequeño a grande, debe escribir la implementación como se define en la documentación.

public int compareTo(Integer o1, Integer o2) {
     int v1 = (o1);
     int v2 = (o2);
     if(v1 == v2) {
        return 0;
     }
     if(v1 < v2) {
        return -1; //return negative integer if first argument is less than second
     }
     return 1;
}

Si desea que la clasificación se realice en orden inverso, es de grande a pequeño.

public int compareTo(Integer o1, Integer o2) {
     int v1 = (o1);
     int v2 = (o2);
     if(v1 == v2) {
        return 0;
     }
     if(v1 < v2) {
        return 1;  //do the other way
     }
     return -1;
}

Answer 4

Tú (o mejor dicho, tu comparador) decide.

• Si la compare(T o1, T o2) su Comparator compare(T o1, T o2) devuelve un negativo cuando o1 es menor que o2 , se obtiene un orden ascendente ( demo en ideone ).
• Si la compare(T o1, T o2) su Comparator compare(T o1, T o2) devuelve un negativo cuando o1 es mayor que o2 , se obtiene un orden descendente ( demo en ideone ).

Otra forma de decir lo mismo sería que la sort asume que el comparador ordena los dos elementos que se le pasan de menor a ( o1 ) a mayor ( o2 ), y produce una ordenación ascendente compatible con ese orden.