Сортировка массива в 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] );
}
Ответы
Ответ 1
Циклы также очень полезны для изучения, 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();
Ответ 2
Добавьте строку перед println, и ваш массив будет отсортирован
Arrays.sort( array );
Ответ 3
Это может помочь вам понять петли, внедряя себя. См. 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)
Ответ 4
Посмотрите Arrays.sort()
Ответ 5
Я ленился и добавил петли
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 );
Является библиотечным методом, который сортирует массивы.
Ответ 6
Arrays.sort(yourArray)
отлично выполнит работу
Ответ 7
См. ниже, это даст вам отсортированный по возрастанию и убыванию обоих
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 вместо добавления ручных номеров. Дайте мне знать, если мне нужно изменить код...
Удачи... Приветствия!
Ответ 8
Вот как это использовать в вашей программе:
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] );
}
Ответ 9
просто FYI, теперь вы можете использовать новый API Java 8 для сортировки любого типа массива с помощью parallelSort
parallelSort
использует инфраструктуру Fork/Join, введенную в Java 7, чтобы назначить задачи сортировки нескольким потокам, доступным в пуле потоков.
два метода, которые можно использовать для сортировки массива int
,
parallelSort(int[] a)
parallelSort(int[] a,int fromIndex,int toIndex)
Ответ 10
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;
}
}
}
Ответ 11
Для естественного заказа: Arrays.sort(array)
Для обратного порядка: Arrays.sort(array, Collections.reverseOrder());
→ Это статический метод в классе Collections, который будет дополнительно вызывать внутренний класс для возврата обратного компаратора.
Ответ 12
Вы можете отсортировать массив int с помощью Arrays.sort( array )
.
Ответ 13
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 не имеет возможности сортировать примитивы с пользовательским компаратором, мы должны использовать промежуточный бокс или другую стороннюю библиотеку, которая реализует такую примитивную сортировку.
Ответ 14
Вот что я сделал:
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;
}
}
}
Ответ 15
Вы можете использовать функцию Arrays.sort().
sort() method is a java.util.Arrays class method.
Declaration : Arrays.sort(arrName)
Ответ 16
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]);
}
}
}
Ответ 17
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;
}
Ответ 18
**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)); }
}
Ответ 19
САМЫЙ ЭФФЕКТИВНЫЙ ПУТЬ!
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+" ");
}
Ответ 20
Элегантное решение - использовать 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);
Ответ 21
Вам может понравиться следующее:
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.
Ответ 22
Простое решение:
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));
}
Ответ 23
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]);
}
}
}
Ответ 24
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 для быстрого сортировки для примитивных типов данных
Ответ 25
Если вы хотите самостоятельно построить алгоритм быстрой сортировки и лучше понять, как он работает, проверьте код ниже:
1- Создать класс сортировки
class QuickSort {
private int input[];
private int length;
public void sort(int[] numbers) {
if (numbers == null || numbers.length == 0) {
return;
}
this.input = numbers;
length = numbers.length;
quickSort(0, length - 1);
}
/*
* This method implements in-place quicksort algorithm recursively.
*/
private void quickSort(int low, int high) {
int i = low;
int j = high;
// pivot is middle index
int pivot = input[low + (high - low) / 2];
// Divide into two arrays
while (i <= j) {
/**
* As shown in above image, In each iteration, we will identify a
* number from left side which is greater then the pivot value, and
* a number from right side which is less then the pivot value. Once
* search is complete, we can swap both numbers.
*/
while (input[i] < pivot) {
i++;
}
while (input[j] > pivot) {
j--;
}
if (i <= j) {
swap(i, j);
// move index to next position on both sides
i++;
j--;
}
}
// calls quickSort() method recursively
if (low < j) {
quickSort(low, j);
}
if (i < high) {
quickSort(i, high);
}
}
private void swap(int i, int j) {
int temp = input[i];
input[i] = input[j];
input[j] = temp;
}
}
2- Отправьте свой несортированный массив в класс Quicksort
import java.util.Arrays;
public class QuickSortDemo {
public static void main(String args[]) {
// unsorted integer array
int[] unsorted = {6, 5, 3, 1, 8, 7, 2, 4};
System.out.println("Unsorted array :" + Arrays.toString(unsorted));
QuickSort algorithm = new QuickSort();
// sorting integer array using quicksort algorithm
algorithm.sort(unsorted);
// printing sorted array
System.out.println("Sorted array :" + Arrays.toString(unsorted));
}
}
3- Вывод
Unsorted array :[6, 5, 3, 1, 8, 7, 2, 4]
Sorted array :[1, 2, 3, 4, 5, 6, 7, 8]
Ответ 26
Я использую цикл для установки значений массива
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
Ответ 27
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);
}
}
}
Ответ 28
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));
}
}
Ответ 29
В коде вам должно понравиться.
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]);
}