Java Arrays.sort()如何实现对int类型数组倒序排序
作者：mp-ui
Java Arrays.sort()实现对int类型数组倒序排序
Java的Arrays.sort()仅支持对引用数据类型进行自定义排序，如果是基本数据类型（如int类型），将无法使用Comparator进行自定义排序。
可以使用下面的方法来实现
- 1.手动实现排序算法。
- 2.先排序再reverse
int[] nums = new int[]{1,6,4,55,61,3,5,8,4,2,8,15,61,33};
Arrays.sort(nums);
for (int i = 0; i < nums.length/2; i++) {
int temp = nums[i];
nums[i] = nums[nums.length - 1 - i];
nums[nums.length - 1 - i] = temp;
}
System.out.println(Arrays.toString(nums));- 3.转换成Integer[]
int[] nums = new int[]{1,6,4,55,61,3,5,8,4,2,8,15,61,33};
Integer[] temp = new Integer[nums.length];
for (int i = 0; i < temp.length; i++) {
temp[i] = nums[i];
}
Arrays.sort(temp,(i,j)->(j-i));
for (int i = 0; i < nums.length; i++) {
nums[i] = temp[i];
}
System.out.println(Arrays.toString(nums));Arrays.sort()用的是什么排序算法？怎么优化？
Arrays.sort()用的是快速排序算法。相信大家对于这个都是了解的。
算法的思想
选择基准将数组一分为二，基准前面的比基准小，基准后面的比基准大，之后分别对这两部分继续之前的操作，已达到整个数组有序的目的。
算法内容描述
- 先选择一个基准，指向数组开始的指针start和指向数组结束的指针end；
- 当start小于end的时候，如果基准的值小于end指向数组的值时，end往前移动；
- 当基准的值不在小于end指向数组的值的时候，交换两个指针指向的数组的值；
- 然后当基准的值大于start指向数组的值的时候，start往后移动；
- 当基准的值不大于start指向数组的值的时候，交换两个指针指向的数组的值；
- 返回基准的位置并进行递归操作完成排序。
代码如下：
public class Test2 {
public static void swap(int[] arr, int j, int i){
int temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
}
public static int partition(int arr[], int start, int end){
assert(null != arr);
int temp = arr[start];
while(start < end){
while(temp < arr[end] && start < end){
end--;
}
swap(arr, start, end);
while(temp > arr[start] && start < end){
start++;
}
swap(arr, start, end);
}
System.out.println(Arrays.toString(arr) + " " + start);
return start;
}
public static void partitionSort(int arr[], int start, int end){
assert(null != arr);
if(start < end){
int midd = partition(arr, start, end);
partitionSort(arr, start, midd - 1);
partitionSort(arr, midd + 1, end);
}
}
public static void main(String[] args) {
int arr[] = {9,1,5,8,3,7,4,6,2};
Test2.partitionSort(arr, 0, arr.length - 1);
System.out.println(Arrays.toString(arr));
}
}执行结果：
[2, 1, 5, 8, 3, 7, 4, 6, 9] 8
[1, 2, 5, 8, 3, 7, 4, 6, 9] 1
[1, 2, 4, 3, 5, 7, 8, 6, 9] 4
[1, 2, 3, 4, 5, 7, 8, 6, 9] 3
[1, 2, 3, 4, 5, 6, 7, 8, 9] 6
[1, 2, 3, 4, 5, 6, 7, 8, 9]
快速排序的优化
①优化基准的选择
上面的程序选择的基准是数组起始位置，但是跟明显，我们并没有达到想要的理想结果将数组划分为两部分，进行递归操作；
所以就有了三数取中法来选取基准，即取三个关键字先进行排序，将中间数作为基准，一般去开始，结束，和中间；
当然也可以随机选取；其实还有一种九数取中法，这里就不详细介绍了，有兴趣的可以自己了解一下。
下面是三数取中法的代码：
public void medianOfThree(int[] arr, int start, int end){
int m = start + (end - start) / 2;
if(arr[start] > arr[end]){
swap(arr, start, end);
}
if(arr[m] > arr[end]){
swap(arr, end, m);
}
if(arr[m] > arr[start]){
swap(arr, m, start);
}
}②优化不必要的交换
首先我们通过上面的代码很容易发现在交换的过程中，有许多部分是没必要交换的，于是我们通过赋值替代交换来省去没必要的交换；
代码如下：
public int partition3(int arr[], int start, int end){
assert(null != arr);
medianOfThree(arr, start, end);
int temp = arr[start];
while(start < end){
while(temp < arr[end] && start < end){
end--;
}
arr[start] = arr[end];
while(temp > arr[start] && start < end){
start++;
}
arr[end] = arr[start];
}
arr[start] = temp;
System.out.println(Arrays.toString(arr) + " " + start);
return start;
}③优化小数组时的排序方案
一般对于小数组排序，我们需要选择插入排序，因为插入排序是简单排序性能最高的。所以我们做如下修改：
public void partitionSort4(int arr[], int start, int end){
assert(null != arr);
if((end - start) > INSERT_SORT){
int midd = partition3(arr, start, end);
partitionSort3(arr, start, midd - 1);
partitionSort3(arr, midd + 1, end);
}else{
insertSort(arr);
}
}其中，INSERT_SORT选择的大小众说纷纭，自我觉得在海量数据面前，选择20跟选择7没有太大的差异吧。（这话如果有误，望大家批评指正）
④优化递归操作
我们都知道递归的额外花销还是很大的，减少递归可以大大提高性能，故此做如下修改：
public void partitionSort5(int arr[], int start, int end){
assert(null != arr);
int midd;
if((end - start) > INSERT_SORT){
while(start < end){
midd = partition3(arr, start, end);
partitionSort5(arr, start, midd - 1);
start = midd + 1;
}
}else{
insertSort(arr);
}
}总结
以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。