Сортировка массивов примитивных типов в порядке убывания

У меня есть большой массив примитивных типов (double). Как 9X_openjdk отсортировать элементы в порядке убывания?

К сожалению, Java 9X_array-sorting API не поддерживает сортировку примитивных 9X_java-se типов с помощью компаратора.

Первый подход, который, вероятно, приходит 9X_date-sorting в голову, - это преобразовать его в список 9X_jre объектов (бокс):

double[] array = new double[1048576];    
Arrays.stream(array).boxed().sorted(Collections.reverseOrder())…

Однако упаковка каждого 9X_openjdk примитива в массиве слишком медленная и вызывает сильную нагрузку на сборщик мусора!

Другой подход - отсортировать, а 9X_java затем перевернуть:

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

Этот подход также медленный - особенно если массив 9X_sorting-algorithm уже достаточно хорошо отсортирован.

Какая 9X_oraclejdk альтернатива лучше?

65
0
11
Общее количество ответов: 11

Ответ #1

Ответ на вопрос: Сортировка массивов примитивных типов в порядке убывания

Думаю, лучше не изобретать колесо заново, а 9X_jre использовать Arrays.sort().

Да, я видел "нисходящую" часть. Сортировка 9X_sort - сложная часть, и вы хотите извлечь выгоду 9X_.java из простоты и скорости кода библиотеки Java. Как 9X_sort только это будет сделано, вы просто переворачиваете 9X_sorting массив, что является относительно дешевой 9X_array-sorting операцией O (n). Here's some code Я обнаружил, что для этого 9X_.java нужно всего 4 строчки:

for (int left=0, right=b.length-1; left

28
0

Ответ #2

Ответ на вопрос: Сортировка массивов примитивных типов в порядке убывания

Java Primitive включает функции для сортировки примитивных 9X_sorting-algorithm массивов на основе настраиваемого компаратора. Используя 9X_sort его и Java 8, ваш образец может быть записан 9X_sort как:

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

Если вы используете Maven, вы можете 9X_sorting-algorithm включить его с помощью:


    net.mintern
    primitive
    1.2.1

Когда вы передаете 9X_java-se false в качестве третьего аргумента для sort, он 9X_oraclejdk использует нестабильную сортировку, простое 9X_core-java редактирование встроенного в Java dual-pivot quicksort. Это 9X_j2se означает, что скорость должна быть близка 9X_java-libraries к скорости встроенной сортировки.

Полное 9X_jre раскрытие: я написал библиотеку Java Primitive.

24
1

  • Это отличный простой проект на GitHub. Очень хорошая работа! ...

Ответ #3

Ответ на вопрос: Сортировка массивов примитивных типов в порядке убывания

Вот однострочный, с использованием потоков 9X_core-java в Java 8

int arr = new int[]{1,2,3,4,5};
Arrays.stream(arr).boxed().sorted(Collections.reverseOrder()).mapToInt(Integer::intValue).toArray();

13
1

  • ** Упаковка ** каждого примитива в массиве с ...

Ответ #4

Ответ на вопрос: Сортировка массивов примитивных типов в порядке убывания

Guava имеет методы для преобразования примитивных 9X_array-sorting массивов в списки типов оболочек. Приятно 9X_openjdk то, что эти списки представляют собой живые 9X_sorted представления, поэтому операции с ними работают 9X_core-java и с базовыми массивами (аналогично Arrays.asList(), но 9X_core-java для примитивов).

В любом случае каждый из 9X_sort этих списков можно передать в 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));

Вывод:

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

8
1

  • `Ints.asList (intArr) .sort()` создает копию базового массива и сортирует к ...

Ответ #5

Ответ на вопрос: Сортировка массивов примитивных типов в порядке убывания

Ваша реализация (та, о которой идет речь) быстрее, чем, например, упаковка 9X_sorting с помощью toList() и использование метода на основе 9X_java компаратора. Автоматическая упаковка и запуск 9X_java методов компаратора или обернутых объектов 9X_jdk коллекций намного медленнее, чем просто 9X_array-sorting реверсирование.

Конечно, вы можете написать 9X_date-sorting свою сортировку. Возможно, это не тот ответ, который 9X_core-java вы ищете, но обратите внимание, что если ваш 9X_array-sorting комментарий о том, что «массив уже отсортирован 9X_j2se достаточно хорошо» случается часто, вы можете 9X_java-api выбрать алгоритм сортировки, который обрабатывает 9X_oraclejdk в этом случае хорошо (например, вставка), а 9X_sorting не использовать Arrays.sort() (который является сортировкой 9X_array-sorting слиянием или вставкой, если количество элементов 9X_jdk невелико).

2
1

  • Вы не можете вызвать Arrays.toList для double [] и заставить его делать то, что вы хотите; В Arrays.toList необход ...

Ответ #6

Ответ на вопрос: Сортировка массивов примитивных типов в порядке убывания

Вы не можете использовать компараторы для 9X_jre сортировки примитивных массивов.

Лучше всего 9X_core-java реализовать (или позаимствовать реализацию) алгоритма 9X_sorted сортировки, который является appropriate для вашего 9X_java-se варианта использования для сортировки массива 9X_java-api (в обратном порядке в вашем случае).

2
0

Ответ #7

Ответ на вопрос: Сортировка массивов примитивных типов в порядке убывания

Я думаю, что самым простым решением остается:

  1. Получение естественного порядка массива
  2. Нахождение максимума в отсортированном массиве, который затем является последним элементом.
  3. Использование цикла for с оператором декремента

Как 9X_oraclejdk уже говорили другие: использование toList 9X_openjdk требует дополнительных усилий, Arrays.sort 9X_sorted (array, Collections.reverseOrder()) не работает 9X_date-sorting с примитивами, и использование дополнительной 9X_core-java структуры кажется слишком сложным, когда 9X_.java все, что вам нужно, уже встроено и, следовательно, наверное, и 9X_core-java быстрее ...

Пример кода:

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

2
0

Ответ #8

Ответ на вопрос: Сортировка массивов примитивных типов в порядке убывания

Before sorting the given array multiply each element by -1 

затем используйте Arrays.sort (arr), затем 9X_java снова умножьте каждый элемент на -1

for(int i=0;i
2
0

Ответ #9

Ответ на вопрос: Сортировка массивов примитивных типов в порядке убывания

В других ответах была некоторая путаница 9X_sorting по поводу Arrays.asList. Если вы скажете

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

тогда у вас будет 9X_.java список с 1 элементом. Результирующий список 9X_sorting-algorithm имеет массив double [] в качестве собственного 9X_.java элемента. Вам нужно иметь List, элементы которого 9X_java-api являются элементами double[].

К сожалению, никакое 9X_array-sorting решение с использованием компараторов не 9X_.java будет работать для примитивного массива. Arrays.sort принимает 9X_array-sorting компаратор только при передаче Object[]. И по причинам, описанным 9X_j2se выше, Arrays.asList не позволит вам создать список из 9X_.java элементов вашего массива.

Итак, несмотря 9X_java на мой предыдущий ответ, на который ссылаются 9X_array-sorting комментарии ниже, нет лучшего способа, чем 9X_sort вручную изменить массив после сортировки. Любой 9X_sorting-algorithm другой подход (например, копирование элементов 9X_openjdk в Double[] и обратная сортировка и копирование их 9X_java обратно) потребует больше кода и будет медленнее.

1
0

Ответ #10

Ответ на вопрос: Сортировка массивов примитивных типов в порядке убывания

Если производительность важна, а список 9X_sorting обычно уже отсортирован достаточно хорошо.

Пузырьковая 9X_sort сортировка должна быть одним из самых медленных 9X_j2se способов сортировки, но я видел случаи, когда 9X_date-sorting наилучшей производительностью была простая 9X_.java двунаправленная пузырьковая сортировка.

Так 9X_core-java что это может быть один из немногих случаев, когда 9X_j2se вы можете извлечь выгоду из написания кода 9X_java-api самостоятельно. Но вам действительно нужно 9X_sorting-algorithm сделать это правильно (убедитесь, что хотя 9X_sorting-algorithm бы кто-то еще подтвердил ваш код, докажите, что 9X_sorting-algorithm он работает и т. Д.)

Как заметил кто-то другой, может 9X_sort быть даже лучше начать с отсортированного 9X_array-sorting массива и сохранять его отсортированным, пока 9X_sorting вы меняете содержимое. Это может работать 9X_javax даже лучше.

1
0

Ответ #11

Ответ на вопрос: Сортировка массивов примитивных типов в порядке убывания

Для числовых типов отрицание элементов до 9X_sorted и после сортировки кажется вариантом. Скорость 9X_javax относительно одиночного реверса после сортировки 9X_sorted зависит от кеша, и если обратный ход не 9X_java-se быстрее, любая разница вполне может быть 9X_sort потеряна из-за шума.

1
1

  • Теперь, когда у меня достаточно репутации для комментариев, я все еще думаю, что это ответ: он описывает «Как [] сортироват ...