java - float - Ordenar matrices de tipos primitivos en orden descendente

tipos de datos primitivos en c

Question

Tengo una gran variedad de tipos primitivos (dobles). ¿Cómo ordeno los elementos en orden descendente ?

Lamentablemente, la API de Java no admite la clasificación de tipos primitivos con un Comparador.

Una solución alternativa sería ordenar y luego revertir:

double[] array = new double[1048576];
...
Arrays.sort(array);
// reverse the array
for(int i=0;i<array.length/2;i++) {
     // swap the elements
     double temp = array[i];
     array[i] = array[array.length-(i+1)];
     array[array.length-(i+1)] = temp;
}

Esto es lento, especialmente si la matriz ya está ordenada bastante bien.

¿Cuál es una mejor alternativa?

Answer 1

A continuación está mi solución, puedes adaptarla a tus necesidades.

¿Como funciona? Toma una matriz de enteros como argumentos. Después de eso, creará una nueva matriz que contendrá los mismos valores que la matriz de los argumentos. La razón de hacer esto es dejar la matriz original intacta.

Una vez que la nueva matriz contiene los datos copiados, lo ordenamos intercambiando los valores hasta que la condición if (newArr [i] <newArr [i + 1]) se evalúe como falsa. Eso significa que la matriz está ordenada en orden descendente.

Para una explicación completa, consulte la publicación de mi blog here .

public static int[] sortDescending(int[] array)
{
    int[] newArr = new int[array.length];

    for(int i = 0; i < array.length; i++)
    {
        newArr[i] = array[i];
    }

    boolean flag = true;
    int tempValue;

    while(flag) 
    {
        flag = false;

        for(int i = 0; i < newArr.length - 1; i++) 
        {
            if(newArr[i] < newArr[i+1])
            {
                tempValue = newArr[i];
                newArr[i] = newArr[i+1];
                newArr[i+1] = tempValue;
                flag = true;
            }
        }
    }

    return newArr;
}

Answer 2

Con tipos numéricos, negar los elementos antes y después de ordenar parece una opción. La velocidad relativa a una sola marcha atrás después de la clasificación depende de la caché, y si el retroceso no es más rápido, cualquier diferencia puede perderse en el ruido.

Answer 3

Creo que la solución más fácil es todavía:

1. Obtener el orden natural de la matriz
2. Encontrar el máximo dentro de la matriz ordenada que es el último elemento
3. Usando un for-loop con operador de decremento

Como dijeron otros antes: usar toList es un esfuerzo adicional, Arrays.sort (array, Collections.reverseOrder ()) no funciona con primitivos y el uso de un marco adicional parece demasiado complicado cuando todo lo que necesita ya está incorporado y, por lo tanto, probablemente sea más rápido. bien...

Código de muestra:

import java.util.Arrays;

public class SimpleDescending {

    public static void main(String[] args) {

        // unsorted array
        int[] integerList = {55, 44, 33, 88, 99};

        // Getting the natural (ascending) order of the array
        Arrays.sort(integerList);

        // Getting the last item of the now sorted array (which represents the maximum, in other words: highest number)
        int max = integerList.length-1;

        // reversing the order with a simple for-loop
        System.out.println("Array in descending order:");
        for(int i=max; i>=0; i--) {
            System.out.println(integerList[i]);
        }

        // You could make the code even shorter skipping the variable max and use
        // "int i=integerList.length-1" instead of int "i=max" in the parentheses of the for-loop
    }
}

Answer 4

Creo que sería mejor no reinventar la rueda y usar Arrays.sort ().

Sí, vi la parte "descendente". La clasificación es la parte difícil, y desea beneficiarse de la simplicidad y velocidad del código de la biblioteca de Java. Una vez hecho esto, simplemente invierte la matriz, que es una operación O (n) relativamente barata. Aquí hay un código que encontré para hacer esto en tan solo 4 líneas:

for (int left=0, right=b.length-1; left<right; left++, right--) {
    // exchange the first and last
    int temp = b[left]; b[left]  = b[right]; b[right] = temp;
}

Answer 5

Ha habido cierta confusión sobre Arrays.asList en las otras respuestas. Si usted dice

double[] arr = new double[]{6.0, 5.0, 11.0, 7.0};
List xs = Arrays.asList(arr);
System.out.println(xs.size());  // prints 1

entonces tendrás una Lista con 1 elemento. La Lista resultante tiene la matriz doble [] como su propio elemento. Lo que quiere es tener una List<Double> cuyos elementos son los elementos del double[] .

Desafortunadamente, ninguna solución que implique Comparadores funcionará para una matriz primitiva. Arrays.sort solo acepta un Comparador al pasar un Object[] . Y por las razones descritas anteriormente, Arrays.asList no le permitirá hacer una lista de los elementos de su matriz.

Por lo tanto, a pesar de mi respuesta anterior, que los comentarios a continuación hacen referencia, no hay mejor manera que revertir manualmente la matriz después de ordenarla. Cualquier otro enfoque (como copiar los elementos en un Double[] y ordenarlos de forma inversa y copiarlos de nuevo) sería más código y más lento.

Answer 6

No conozco ninguna instalación de clasificación primitiva dentro de la API central de Java.

A partir de mis experimentos con el lenguaje de programación D (una especie de C sobre esteroides), descubrí que el algoritmo de ordenación por fusión es posiblemente el algoritmo de ordenación de propósito general más rápido (es lo que el lenguaje D usa para implementar su función de clasificación) .

• Una implementación en Java
• Otra implementación
• Una implementación más

Answer 7

No puede usar comparadores para ordenar matrices primitivas.

Su mejor opción es implementar (o tomar prestada una implementación) un algoritmo de clasificación que sea appropriate para su caso de uso para ordenar la matriz (en orden inverso en su caso).

Answer 8

Si el rendimiento es importante, y la lista generalmente ya está ordenada bastante bien.

El ordenamiento de burbujas debería ser una de las formas más lentas de clasificación, pero he visto casos en los que el mejor rendimiento fue un tipo de burbuja bidireccional simple.

Así que este puede ser uno de los pocos casos en los que puede beneficiarse al codificarlo usted mismo. Pero realmente debe hacerlo bien (asegúrese de que al menos alguien más confirme su código, compruebe que funciona, etc.)

Como alguien más señaló, puede ser aún mejor comenzar con una matriz ordenada, y mantenerla ordenada mientras usted cambia los contenidos. Eso puede funcionar aún mejor.

Answer 9

Si usa java8, simplemente convierta la matriz en transmisión, ordene y convierta de nuevo. Todas las tareas se pueden hacer solo en una línea, así que siento que no es tan malo.

double[] nums = Arrays.stream(nums).boxed().
        .sorted((i1, i2) -> Double.compare(i2, i1))
        .mapToDouble(Double::doubleValue)
        .toArray();

Answer 10

Su implementación (la de la pregunta) es más rápida que, por ejemplo, envolviendo con toList() y usando un método basado en comparador. El auto-boxeo y la ejecución a través de los métodos de comparación o los objetos de Colecciones envueltos es mucho más lento que simplemente invertir.

Por supuesto, podrías escribir tu propio tipo. Puede que esa no sea la respuesta que estás buscando, pero ten en cuenta que si tu comentario sobre "si la matriz ya está bastante bien organizada" ocurre con frecuencia, es mejor que elijas un algoritmo de clasificación que maneje bien ese caso (por ejemplo, inserción) en lugar de usar Arrays.sort() (que es mergesort, o inserción si la cantidad de elementos es pequeña).

Answer 11

Tu algoritmo es correcto Pero podemos hacer la optimización de la siguiente manera: mientras invierte, puede intentar mantener otra variable para reducir el contador hacia atrás, ya que la computación de array.length- (i + 1) puede llevar tiempo. Y también mueva la declaración de temperatura afuera para que cada vez que no necesite ser asignado

double temp;

for(int i=0,j=array.length-1; i < (array.length/2); i++, j--) {

     // swap the elements
     temp = array[i];
     array[i] = array[j];
     array[j] = temp;
}

Answer 12

Un enfoque mejor y más conciso podría ser:

    Arrays.sort(array);
List<Integer> list=Arrays.asList(array);
Collections.reverse(list);
System.out.println(list);

Esto daría la matriz invertida y es más presentable. Entrada: 4 2 9 5 3 Salida: [9, 5, 4, 3, 2]

Answer 13

para matrices pequeñas esto puede funcionar.

int getOrder (double num, double[] array){
    double[] b = new double[array.length];
    for (int i = 0; i < array.length; i++){
        b[i] = array[i];
    }
    Arrays.sort(b);
    for (int i = 0; i < b.length; i++){
        if ( num < b[i]) return i;
    }
    return b.length;
}

Me sorprendió que la carga inicial de la matriz b fuera necesaria

double[] b = array; // makes b point to array. so beware!

Answer 14

Guava tiene métodos para convertir matrices primitivas en Listas de tipos de envoltura. Lo bueno es que estas listas son vistas en vivo, por lo que las operaciones en ellas también funcionan en las matrices subyacentes (similar a Arrays.asList() , pero para las primitivas).

De todos modos, cada una de estas listas se puede pasar a Collections.reverse() :

int[] intArr = { 1, 2, 3, 4, 5 };
float[] floatArr = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };
double[] doubleArr = { 1.0d, 2.0d, 3.0d, 4.0d, 5.0d };
byte[] byteArr = { 1, 2, 3, 4, 5 };
short[] shortArr = { 1, 2, 3, 4, 5 };
Collections.reverse(Ints.asList(intArr));
Collections.reverse(Floats.asList(floatArr));
Collections.reverse(Doubles.asList(doubleArr));
Collections.reverse(Bytes.asList(byteArr));
Collections.reverse(Shorts.asList(shortArr));
System.out.println(Arrays.toString(intArr));
System.out.println(Arrays.toString(floatArr));
System.out.println(Arrays.toString(doubleArr));
System.out.println(Arrays.toString(byteArr));
System.out.println(Arrays.toString(shortArr));

Salida:

[5, 4, 3, 2, 1]
[5.0, 4.0, 3.0, 2.0, 1.0]
[5.0, 4.0, 3.0, 2.0, 1.0]
[5, 4, 3, 2, 1]
[5, 4, 3, 2, 1]

Answer 15

Java Primitive incluye funcionalidad para ordenar matrices primitivas basadas en un comparador personalizado. Utilizándolo, y Java 8, su muestra podría escribirse como:

double[] array = new double[1048576];
...
Primitive.sort(array, (d1, d2) -> Double.compare(d2, d1), false);

Si está usando Maven, puede incluirlo con:

<dependency>
    <groupId>net.mintern</groupId>
    <artifactId>primitive</artifactId>
    <version>1.2.1</version>
</dependency>

Cuando pasa false como el tercer argumento para sort , usa una ordenación inestable, una edición simple de la conexión rápida de doble pivote incorporada de Java. Esto significa que la velocidad debe ser similar a la de la clasificación incorporada.

Descripción completa: escribí la biblioteca Java Primitive.

Answer 16

Before sorting the given array multiply each element by -1 

luego usa Arrays.sort (arr) luego otra vez multiplica cada elemento por -1

for(int i=0;i<arr.length;i++)
    arr[i]=-arr[i];
Arrays.sort(arr);
for(int i=0;i<arr.length;i++)
    arr[i]=-arr[i];

Answer 17

Double[] d = {5.5, 1.3, 8.8};
Arrays.sort(d, Collections.reverseOrder());
System.out.println(Arrays.toString(d));

Collections.reverseOrder () no funciona en primitivas, pero Double, Integer etc. funciona con Collections.reverseOrder ()

Answer 18

double[] array = new double[1048576];

...

Por defecto el orden es ascendente

Para invertir el orden

Arrays.sort(array,Collections.reverseOrder());