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

Question

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

К сожалению, Java API не поддерживает сортировку примитивных типов с помощью Comparator.

Один из обходных путей - отсортировать, а затем развернуть:

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

Это медленно - особенно если массив уже отсортирован довольно хорошо.

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

Answer 1

double s =-1;
   double[] n = {111.5, 111.2, 110.5, 101.3, 101.9, 102.1, 115.2, 112.1};
   for(int i = n.length-1;i>=0;--i){
      int k = i-1;
      while(k >= 0){
          if(n[i]>n[k]){
              s = n[k];
              n[k] = n[i];
              n[i] = s;
          }
          k --;
      }
   }
   System.out.println(Arrays.toString(n));
 it gives time complexity O(n^2) but i hope its work

Answer 2

Понимаю, что это очень старый пост, но я наткнулся на похожую проблему, пытаясь отсортировать примитивные массивы int, поэтому публикую свое решение. Предложения / комментарии приветствуются -

int[] arr = {3,2,1,3};
List<Integer> list = new ArrayList<>();
Arrays.stream(arr).forEach(i -> list.add(i));
list.stream().sorted(Comparator.reverseOrder()).forEach(System.out::println);

Answer 3

В Java 8 лучшим и более кратким подходом может быть:

double[] arr = {13.6, 7.2, 6.02, 45.8, 21.09, 9.12, 2.53, 100.4};

Double[] boxedarr = Arrays.stream( arr ).boxed().toArray( Double[]::new );
Arrays.sort(boxedarr, Collections.reverseOrder());
System.out.println(Arrays.toString(boxedarr));

Это даст обратный массив и будет более презентабельным.

Ввод: [13,6, 7,2, 6,02, 45,8, 21,09, 9,12, 2,53, 100,4]

Выход: [100,4, 45,8, 21,09, 13,6, 9,12, 7,2, 6,02, 2,53]

Answer 4

Ниже мое решение, вы можете адаптировать его к вашим потребностям.

Как это работает? Он принимает массив целых чисел в качестве аргументов. После этого он создаст новый массив, который будет содержать те же значения, что и массив из аргументов. Причина этого состоит в том, чтобы оставить исходный массив без изменений.

Как только новый массив содержит скопированные данные, мы сортируем их, меняя их значения до условия if (newArr [i] оценивается как false Это означает, что массив отсортирован в порядке убывания.

Для подробного объяснения проверьте мой пост в блоге здесь .

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 5

Если вы используете java8, просто конвертируйте массив в поток, сортируйте и конвертируйте обратно. Все задачи могут быть выполнены в одну строку, поэтому я считаю, что это не так уж плохо.

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

Answer 6

для небольших массивов это может работать.

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

Я был удивлен, что первоначальная загрузка массива b была необходима

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

Answer 7

Мне не известны какие-либо примитивные средства сортировки в API ядра Java.

Из моих экспериментов с D языком программирования (разновидность C на стероидах) я обнаружил, что алгоритм сортировки слиянием, возможно, самый быстрый алгоритм сортировки общего назначения (это то, что сам язык использует для реализации своей функции сортировки).

• Одна реализация в Java
• Другая реализация
• Еще одна реализация

Answer 8

Ваш алгоритм правильный. Но мы можем сделать оптимизацию следующим образом: В обратном направлении вы можете попытаться сохранить другую переменную для уменьшения обратного счетчика, поскольку вычисление array.length- (i + 1) может занять время! А также переместите объявление temp наружу, чтобы каждый раз его не нужно было выделять

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 9

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

Collections.reverseOrder () не работает с примитивами, но Double, Integer и т. Д. Работают с Collections.reverseOrder ()

Answer 10

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

Пузырьковая сортировка должна быть одним из самых медленных способов сортировки, но я видел случаи, когда лучшей производительностью была простая двунаправленная пузырьковая сортировка.

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

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