Сортировка массива в Java

Я пытаюсь создать программу, состоящую из массива из 10 целых чисел, все из которых имеют случайное значение, настолько хорошее.

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

(Извините за то, что у меня так много кода для небольшой программы, я не так хорош с циклами, просто начал работать с Java)

public static void main(String args[])
{
    int [] array = new int[10];

    array[0] = ((int)(Math.random()*100+1));
    array[1] = ((int)(Math.random()*100+1));
    array[2] = ((int)(Math.random()*100+1));
    array[3] = ((int)(Math.random()*100+1));
    array[4] = ((int)(Math.random()*100+1));
    array[5] = ((int)(Math.random()*100+1));
    array[6] = ((int)(Math.random()*100+1));
    array[7] = ((int)(Math.random()*100+1));
    array[8] = ((int)(Math.random()*100+1));
    array[9] = ((int)(Math.random()*100+1));

    System.out.println(array[0] +" " + array[1] +" " + array[2] +" " + array[3]
    +" " + array[4] +" " + array[5]+" " + array[6]+" " + array[7]+" " 
    + array[8]+" " + array[9] );        

}
4b9b3361

Циклы также очень полезны для изучения, esp При использовании массивов

int[] array = new int[10];
Random rand = new Random();
for (int i = 0; i < array.length; i++)
    array[i] = rand.nextInt(100) + 1;
Arrays.sort(array);
System.out.println(Arrays.toString(array));
// in reverse order
for (int i = array.length - 1; i >= 0; i--)
    System.out.print(array[i] + " ");
System.out.println();
180
ответ дан 20 янв. '12 в 10:56
источник

Добавьте строку перед println, и ваш массив будет отсортирован

Arrays.sort( array );
172
ответ дан 20 янв. '12 в 10:53
источник

Это может помочь вам понять петли, внедряя себя. См. Bubble sort легко понять:

public void bubbleSort(int[] array) {
    boolean swapped = true;
    int j = 0;
    int tmp;
    while (swapped) {
        swapped = false;
        j++;
        for (int i = 0; i < array.length - j; i++) {
            if (array[i] > array[i + 1]) {
                tmp = array[i];
                array[i] = array[i + 1];
                array[i + 1] = tmp;
                swapped = true;
            }
        }
    }
}

Конечно, вы не должны использовать его в процессе производства, так как для больших списков есть более эффективные алгоритмы, такие как QuickSort или MergeSort, которые реализованы Arrays.sort(array)

35
ответ дан 20 янв. '12 в 10:55
источник

Я ленился и добавил петли

import java.util.Arrays;


public class Sort {
    public static void main(String args[])
    {
        int [] array = new int[10];
        for ( int i = 0 ; i < array.length ; i++ ) {
            array[i] = ((int)(Math.random()*100+1));
        }
        Arrays.sort( array );
        for ( int i = 0 ; i < array.length ; i++ ) {
            System.out.println(array[i]);
        }
    }
}

Ваш массив имеет длину 10. Вам нужна одна переменная (i), которая принимает значения от 0 до 9.

for ( int i = 0  ; i < array.length ;   i++ ) 
       ^               ^                   ^
       |               |                   ------  increment ( i = i + 1 )
       |               |
       |               +-------------------------- repeat as long i < 10
       +------------------------------------------ start value of i


Arrays.sort( array );

Является библиотечным методом, который сортирует массивы.

17
ответ дан 20 янв. '12 в 10:56
источник

См. ниже, это даст вам отсортированный по возрастанию и убыванию обоих

import java.util.Arrays;
import java.util.Collections;

public class SortTestArray {

/**
 * Example method for sorting an Integer array
 * in reverse & normal order.
 */
public void sortIntArrayReverseOrder() {

    Integer[] arrayToSort = new Integer[] {
        new Integer(48),
        new Integer(5),
        new Integer(89),
        new Integer(80),
        new Integer(81),
        new Integer(23),
        new Integer(45),
        new Integer(16),
        new Integer(2)
    };

    System.out.print("General Order is    : ");

    for (Integer i : arrayToSort) {
        System.out.print(i.intValue() + " ");
    }


    Arrays.sort(arrayToSort);

    System.out.print("\n\nAscending Order is  : ");

    for (Integer i : arrayToSort) {
        System.out.print(i.intValue() + " ");
    }


    Arrays.sort(arrayToSort, Collections.reverseOrder());
    System.out.print("\n\nDescinding Order is : ");
    for (Integer i : arrayToSort) {
        System.out.print(i.intValue() + " ");
    }

}


/**
 * @param args the command line arguments
 */
public static void main(String[] args) {
    SortTestArray SortTestArray = new SortTestArray();
    SortTestArray.sortIntArrayReverseOrder();
}}

Выход будет

General Order is    : 48 5 89 80 81 23 45 16 2 

Ascending Order is  : 2 5 16 23 45 48 80 81 89 

Descinding Order is : 89 81 80 48 45 23 16 5 2 

Примечание. Вы можете использовать Math.ranodm вместо добавления ручных номеров. Дайте мне знать, если мне нужно изменить код...

Удачи... Приветствия!

7
ответ дан 20 янв. '12 в 11:21
источник
int[] array = {2, 3, 4, 5, 3, 4, 2, 34, 2, 56, 98, 32, 54};

for (int i = 0; i < array.length; i++) {
    for (int j = 0; j < array.length; j++) {
        if (array[i] < array[j]) {
            int temp = array[i];
            array[i] = array[j];
            array[j] = temp;
        }
    }
}
6
ответ дан 09 апр. '15 в 22:27
источник

Вот как это использовать в вашей программе:

public static void main(String args[])
{
    int [] array = new int[10];

    array[0] = ((int)(Math.random()*100+1));
    array[1] = ((int)(Math.random()*100+1));
    array[2] = ((int)(Math.random()*100+1));
    array[3] = ((int)(Math.random()*100+1));
    array[4] = ((int)(Math.random()*100+1));
    array[5] = ((int)(Math.random()*100+1));
    array[6] = ((int)(Math.random()*100+1));
    array[7] = ((int)(Math.random()*100+1));
    array[8] = ((int)(Math.random()*100+1));
    array[9] = ((int)(Math.random()*100+1));

    Arrays.sort(array); 

    System.out.println(array[0] +" " + array[1] +" " + array[2] +" " + array[3]
    +" " + array[4] +" " + array[5]+" " + array[6]+" " + array[7]+" " 
    + array[8]+" " + array[9] );        

}
6
ответ дан 20 янв. '12 в 10:59
источник

просто FYI, теперь вы можете использовать новый API Java 8 для сортировки любого типа массива с помощью parallelSort

parallelSort использует инфраструктуру Fork/Join, введенную в Java 7, чтобы назначить задачи сортировки нескольким потокам, доступным в пуле потоков.

два метода, которые можно использовать для сортировки массива int,

parallelSort(int[] a)
parallelSort(int[] a,int fromIndex,int toIndex)
6
ответ дан 28 янв. '15 в 17:59
источник

Вы можете отсортировать массив int с помощью Arrays.sort( array ).

5
ответ дан 20 янв. '12 в 10:52
источник

Для естественного порядка: Array.sort(array)

Для обратного порядка: Array.sort(array, Collections.reverseOrder()); → Это статический метод в классе Collections, который далее вызовет внутренний класс для возврата обратного компаратора.

4
ответ дан 11 янв. '17 в 17:30
источник

Вот что я сделал:

System.out.print("Enter number of student: ");
input = myScan.nextInt();

int[] scores = new int[input];
String[] students = new String[input];
try {

    for (int index = 0; index < input; index++) {
        System.out.print("Enter student: ");
        students[index] = myBuff.readLine();
        System.out.print("Enter score for " + students[index] + ": ");
        scores[index] = myScan.nextInt();
    }

    //Sorting the numbers
    for (int index = 0; index < input; index++) {
        for (int index1 = 0; index1 < input - 1; index1++) {
            if (scores[index1] > scores[index1 + 1]) {

                contain = scores[index1];
                containS = students[index1];
                scores[index1] = scores[index1 + 1];
                students[index1] = students[index1 + 1];
                scores[index1 + 1] = contain;
                students[index1 + 1] = containS;

            }
        }
    }
3
ответ дан 27 июля '13 в 6:00
источник

САМЫЙ ЭФФЕКТИВНЫЙ ПУТЬ!

public static void main(String args[])
{
    int [] array = new int[10];//creates an array named array to hold 10 int's
    for(int x: array)//for-each loop!
      x = ((int)(Math.random()*100+1));
    Array.sort(array);
    for(int x: array)
      System.out.println(x+" ");
}
2
ответ дан 10 февр. '15 в 3:52
источник

Java 8 предоставляет возможность использования потоков, которые могут использоваться для сортировки int[] array:

int[] sorted = Arrays.stream(array).sorted().toArray(); // option 1
Arrays.parallelSort(array); //option 2

Как упоминалось в документе для parallelSort:

Алгоритм сортировки представляет собой параллельное сортирование-слияние, которое разбивает массив на под-массивы, которые сами сортируются и затем объединяются. Когда длина поддиапазона достигает минимальной детализации, подматрица сортируется с использованием соответствующего метода Arrays.sort. Если длина указанного массива меньше минимальной гранулярности, то она сортируется с использованием соответствующего метода Arrays.sort. Алгоритм требует рабочего пространства, не превышающего размер исходного массива. Общий пул ForkJoin используется для выполнения любых параллельных задач.

Поэтому, если входной массив меньше гранулярности (8192 элементов в Java 9 и 4096 в Java 8, я считаю), то parallelSort просто вызывает последовательный алгоритм сортировки.

На всякий случай, если мы хотим изменить сортировку массива integer, мы можем использовать компаратор как:

int[] reverseSorted = IntStream.of(array).boxed()
                        .sorted(Comparator.reverseOrder()).mapToInt(i -> i).toArray();

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

2
ответ дан 14 дек. '17 в 14:13
источник
**The complete sorting using for loop in simple format:**
    import java.util.Arrays;
    public class Sorting {
        public static void main(String[] args) {
            int[] array = {14,5,76,45,3};
            for(int i =0;i<array.length;i++) {  
                for(int j =0;j<=array.length-1;j++) {
                    if(array[i] < array[j]) {
                        int temp = array[i];
                        array[i] = array[j];
                        array[j] = temp;
                    }
                }

            }
            System.out.println(Arrays.toString(array)); }
    }
1
ответ дан 11 апр. '18 в 6:10
источник
    int []array = {5,8,2,1,3,0,1,7};
    int min = 0;
    int temp;

    for(int i=0; i<array.length; i++)
    {
        min = i;
        for(int j=i; j< array.length; j++)
        {
            if(array[j] < array[min])
                min = j;

        }
         temp = array[i];
         array[i] = array[min];
         array[min] = temp;
    }
1
ответ дан 01 апр. '15 в 3:52
источник
import java.util.*;

public class Sample4You {

    public static void main(String[] args) {

        int[] YourList = new int[10];
        int x;

        //this is for placing the randomly generated numbers into each index 
        for (x = 1; x < 10; x++) {
            YourList[x] = (int) (Math.random() * 100);
        }

        Arrays.sort(YourList);//we must sort the array "YourList"from least 2 greatest

        //now we print all the numbers 1 by 1 --
        for (x = 0; x < YourList.length; x++) {
            System.out.println("Number in index [" + x + "] = " + YourList[x]);
        }
    }
}
1
ответ дан 24 апр. '14 в 11:38
источник

Элегантное решение - использовать Stream API. Это не лучший способ использовать его здесь, потому что вы тратите ресурсы на конвертацию из int → Integer, но я хотел показать, что Stream API - сильный инструмент для создания любой логики, которую вы хотят в разных ситуациях.

    int[] ints= {53,95,1,3,534,94,4356,5,1,114};
    List<Integer> integers = new ArrayList<>(); 
    Collections.addAll(integers, Arrays.stream(ints).boxed().toArray(Integer[]::new));//Converting int into Integer and put to arrayList
    integers.sort(Comparator.comparingInt(o -> o));//sorting 
    integers.forEach(System.out::println);//printing

С точки зрения производительности лучше использовать класс массивов.

Arrays.sort(ints);
0
ответ дан 20 марта '17 в 13:12
источник

Вам может понравиться следующее:

public static void main(String args[]) {
    int[] array = new int[10];

    array[0] = ((int) (Math.random() * 100 + 1));
    array[1] = ((int) (Math.random() * 100 + 1));
    array[2] = ((int) (Math.random() * 100 + 1));
    array[3] = ((int) (Math.random() * 100 + 1));
    array[4] = ((int) (Math.random() * 100 + 1));
    array[5] = ((int) (Math.random() * 100 + 1));
    array[6] = ((int) (Math.random() * 100 + 1));
    array[7] = ((int) (Math.random() * 100 + 1));
    array[8] = ((int) (Math.random() * 100 + 1));
    array[9] = ((int) (Math.random() * 100 + 1));

    System.out.println(array[0] + " " + array[1] + " " + array[2] + " "
            + array[3] + " " + array[4] + " " + array[5] + " " + array[6]
            + " " + array[7] + " " + array[8] + " " + array[9]);

    Arrays.sort(array);
    System.out.println("After sorting array:: ");
    for (int i = 0; i < array.length; i++) {
        System.out.print(array[i] + " ");
    }
}

Вам нужно импортировать java.util.Arrays; в программу, чтобы использовать метод Arrays.sort.

0
ответ дан 31 окт. '17 в 8:32
источник

import java.util. *;

общественный класс SortAnmol

{

public static void main(String[] args) 
{   
       int[] a = {1,4,2,7};
        Arrays.sort(a);
        for(int i=0;i<4;i++)
        {
            System.out.print(a[i]);
        } 
}

}

0
ответ дан 25 июля '18 в 14:52
источник

Простое решение:

 private static void sortArray(int[] arr) {

    for (int i = 0; i <arr.length-1; i++) {
        for (int j = 1; j <arr.length-i; j++) {

            if(arr[j-1]>arr[j]) {
                int temp = arr[j-1];
                arr[j-1] = arr[j];
                arr[j] = temp;
            }

        }
    }

    System.out.println(Arrays.toString(arr));
}
0
ответ дан 10 янв. '18 в 13:06
источник
import java.io.*;
import java.text.*;
import java.util.*;
import java.util.regex.*;
class A {
 public static void main(String args[]) {
  int[] array = new int[10];
  for (int i = 0; i < 10; i++)
   array[i] = ((int)(Math.random() * 100 + 1));
  Arrays.sort(array);
  for (int i = 0; i < 10; i++)
   System.out.print(array[i] + " ");
 }
}

Самый простой способ Java для быстрого сортировки для примитивных типов данных

0
ответ дан 17 авг. '18 в 15:44
источник
public class Sort{
public static void main(String[] args) {
    int temp;
    int[] a = { 5, 4, 7, 8, 3, 1, 0, 9, 2 };
    for (int i = 0; i < a.length; i++) {
        for (int j = 0; j < a.length; j++) {
            if (a[i] < a[j]) {
                temp = a[i];
                a[i] = a[j];
                a[j] = temp;
            }
        }
    }
    System.out.println(Arrays.toString(a));
}

}

-1
ответ дан 31 июля '18 в 16:37
источник

Я использую цикл для установки значений массива

    int[] array  = new int[10];

for (int i = 0; i < array.length; i++) {
            int x = (int) (Math.random() * 100+1);
            array[i] = x;
        }

        boolean flag = true; //flag to exit while loop
        int tempValue; // temporary value for swapping the array values
        while (flag) {
            flag = false;
            for (int i = 0; i < (array.length) - (1); i++) {
                if (array[i] > array[i + 1]) {
                    tempValue = array[i];
                    array[i] = array[i + 1];
                    array[i + 1] = tempValue;
                    flag = true;
                }
            }
        }
        System.out.println("Ascending order\n" +Arrays.toString(array)); // print the ordered array values
-1
ответ дан 26 окт. '17 в 14:18
источник
public class ArraySorting
{ 
    public static void main(String[]args)
    {
        int[] x = { 14, 5, 76, 45, 3 };
        for (int i = 0; i  < x.length; i++)
        {  
            for (int j = 0; j <= x.length - 1; j++)
            {
                if (x[i] < x[j])
                {
                    int y = x[i];
                    x[i] = x[j];
                    x[j] = y;
                }
            }
        }

        for (int m : x)
        {
            System.out.println(m);
        }
    }
}
-1
ответ дан 12 июля '18 в 2:13
источник

В коде вам должно понравиться.

public static void main(String args[]) {

    int[] array = new int[10];

    array[0] = ((int)(Math.random() * 100 + 1));
    array[1] = ((int)(Math.random() * 100 + 1));
    array[2] = ((int)(Math.random() * 100 + 1));
    array[3] = ((int)(Math.random() * 100 + 1));
    array[4] = ((int)(Math.random() * 100 + 1));
    array[5] = ((int)(Math.random() * 100 + 1));
    array[6] = ((int)(Math.random() * 100 + 1));
    array[7] = ((int)(Math.random() * 100 + 1));
    array[8] = ((int)(Math.random() * 100 + 1));
    array[9] = ((int)(Math.random() * 100 + 1));

    Array.sort(array);

    System.out.println(array[0] + " " + array[1] + " " + array[2] + " " + array[3] + " " + array[4] + " " + array[5] + " " + array[6] + " " + array[7] + " " + array[8] + " " + array[9]);

}
-2
ответ дан 02 дек. '14 в 13:45
источник