用 Java 对数组排序

小开

看看 Arrays.sort ()

小开

可以使用 Arrays.sort( array )对整型数组进行排序。

小开

在 println 之前添加 Line，数组就会被排序

Arrays.sort( array );

小开

它可以通过实现自己来帮助您理解循环。参见 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;
}
}
}
}

当然，您不应该在生产中使用它，因为对于由 Arrays.sort(array)实现的大型列表(如 快速排序或 合并排序) ，有性能更好的算法

小开

我太懒了，就加了个循环

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

是对数组进行排序的库方法。

小开

最佳答案

循环也是非常有用的学习，尤其是当使用数组,

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();

小开

下面是如何在程序中使用它:

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] );


}

小开

看下面，它会给你 同时升序和降序排序

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 代替手动编号。如果需要更改代码，请告诉我..。

祝你好运... 干杯! ! ！

小开

Arrays.sort(yourArray)

会完美地完成这项工作

小开

仅供参考，您现在可以使用 Java8 new API 使用 parallelSort对任何类型的数组进行排序

parallelSort使用 Java7中引入的 Fork/Join 框架将排序任务分配给线程池中可用的多个线程。

可以用来对 int数组进行排序的两种方法,

parallelSort(int[] a)
parallelSort(int[] a,int fromIndex,int toIndex)

小开

最有效的方法！

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+" ");
}

小开

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

小开

自然秩序: Arrays.sort(array)

对于反向顺序: Arrays.sort(array, Collections.reverseOrder());—— > 这是 Collectionsclass 中的一个静态方法，它将进一步调用自身的内部类来返回一个反向比较器。

小开

您可以使用 Arrays.sort ()函数。

sort() method is a java.util.Arrays class method.
Declaration : Arrays.sort(arrName)

小开

Java8 提供了使用流的选项，这些流可以用来按照以下方式对 int[] array进行排序:

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

正如医生中所提到的 parallelSort:

排序算法是一种并行排序合并，它可以破坏数组进入子数组，这些子数组本身被排序，然后合并子数组长度达到最小粒度时，子数组为使用适当的 Arrays.sort 方法进行排序指定的数组小于最小粒度，则为使用适当的 Arrays.sort 方法进行排序所需的工作空间不得大于原件的大小 ForkJoin 公共池用于执行任何并行任务。

因此，如果输入数组的粒度小于(我相信 Java9中有8192个元素，Java8中有4096个元素) ，那么 parallelSort只需调用顺序排序算法。

如果我们想对整数数组进行反向排序，我们可以使用比较器:

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

由于 Java 没有使用自定义比较器对基元进行排序的方法，我们只能使用中间装箱或其他实现这种基元排序的第三方库。

小开

如果您想自己构建快速排序算法，并对其工作原理有更多的了解，请查看下面的代码:

1-创建 sort class

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

将未排序的数组发送到 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]

小开

我们也可以使用二叉查找树通过顺序遍历的方法来得到排序的数组。守则亦具备下列基本二叉查找树的实施方法。

class Util {
public static void printInorder(Node node)
{
if (node == null) {
return;
}


/* traverse left child */
printInorder(node.left);


System.out.print(node.data + " ");


/* traverse right child */
printInorder(node.right);
}


public static void sort(ArrayList<Integer> al, Node node) {
if (node == null) {
return;
}


/* sort left child */
sort(al, node.left);


al.add(node.data);


/* sort right child */
sort(al, node.right);


}
}


class Node {
Node left;
Integer data;
Node right;


public Node(Integer data) {
this.data = data;
}


public void insert(Integer element) {
if(element.equals(data)) {
return;
}


// if element is less than current then we know we will insert element to left-sub-tree
if(element < data) {
// if this node does not have a sub tree then this is the place we insert the element.
if(this.left == null) {
this.left = new Node(element);
} else { // if it has left subtree then we should iterate again.
this.left.insert(element);
}
} else {
if(this.right == null) {
this.right = new Node(element);
} else {
this.right.insert(element);
}
}
}
}


class Tree {
Node root;


public void insert(Integer element) {
if(root == null) {
root = new Node(element);
} else {
root.insert(element);
}
}


public void print() {
Util.printInorder(root);
}


public ArrayList<Integer> sort() {
ArrayList<Integer> al = new ArrayList<Integer>();
Util.sort(al, root);
return al;
}
}


public class Test {


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


Tree tree = new Tree();


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


tree.print();


ArrayList<Integer> al = tree.sort();


System.out.println("sorted array : ");
al.forEach(item -> System.out.print(item + " "));
}

}

小开

注意 Arrays.sort ()方法 不是线程安全的: 如果你的数组是一个单例的属性，并且在多线程环境中使用，你应该把排序代码放在一个同步块中，或者创建一个数组的副本并命令复制(只复制数组结构，使用相同的对象)。

例如:

 int[] array = new int[10];
...
int[] arrayCopy = Arrays.copyOf(array , array .length);
Arrays.sort(arrayCopy);
// use the arrayCopy;

小开

只需在打印数组之前执行以下操作:-

Arrays.sort(array);

注:- 您必须导入数组类，方法是:-

import java.util.Arrays;