JAVA基础之int[]数组逆序排序

1.概述

有一个int[]，数组内有一定数量的元素，将该数组内元素按逆序排序，解析所使用方案的优缺点。假定数组int[] arrs={5,1,6,3,4,9,22,65,77}。

2.思路

2.1 方案一

利用Arrays.sort()方法默认升序排序，升序排序完成后，依次交换int[i]，int[arrs.length -1-i]位置上的元素，即可获得新数组。代码如下：

        long startTime = System.currentTimeMillis();
        Arrays.sort(arrs);
        System.out.println(Arrays.toString(arrs));
        for (int min = 0, max = arrs.length - 1; min < max; min++, max--) {
            int temp = arrs[min];
            arrs[min] = arrs[max];
            arrs[max] = temp;
        }
        long endTime = System.currentTimeMillis();
        System.out.println(Arrays.toString(arrs));
        System.out.println("耗时:" + (endTime - startTime));

运行结果如下：

2.2 方案二

采用冒泡排序的思想，每次取出数组中元素最小的值。代码如下：

   System.out.println(Arrays.toString(arrs));
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < arrs.length; i++) {
            for (int j = arrs.length - 1; j > i; j--) {
                int temp = arrs[i];
                if (arrs[i] < arrs[j]) {
                    arrs[i] = arrs[j];
                    arrs[j] = temp;
                }
            }
        }
        long endTime = System.currentTimeMillis();
        System.out.println(Arrays.toString(arrs));
        System.out.println("耗时:" + (endTime - startTime));

运行结果如下：

2.3 方案三

先调用Arrays.sort()方法将数组排序，再创建一个新数组nums[]，将arrs[arrs.length -i-1]的值赋值给nums[i]，本质还是冒泡排序算法。

       long startTime = System.currentTimeMillis();
       int[] nums = new int[arrs.length];
       System.out.println(Arrays.toString(arrs));
       Arrays.sort(arrs);
       for (int i = 0; i < arrs.length; i++) {
           nums[i] = arrs[arrs.length -i-1];
        }
       long endTime = System.currentTimeMillis();
       System.out.println(Arrays.toString(nums));
       System.out.println("耗时:" + (endTime - startTime));

运行结果如下：

2.4 方案四

利用Arrays.sort()方法中自定义排序规则，由于int[]是原子类型数组，首先需转成对象类数组，具体实现方案如下：

        long startTime = System.currentTimeMillis();
        Integer[] nums = new Integer[arrs.length];
        for (int i = 0; i < arrs.length; i++) {
            nums[i] = arrs[i];
        }
        System.out.println(Arrays.toString(nums));
        Arrays.sort(nums, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });
        long endTime = System.currentTimeMillis();
        System.out.println(Arrays.toString(nums));
        System.out.println("耗时:" + (endTime - startTime));

运行结果如下：

2.5 方案五

利用lambda表达式先将原子类型数组转换为包装类型数组，再自定义new Comparator逆序排序。本质与方案四相同，具体实现方案如下：

        long startTime = System.currentTimeMillis();
        System.out.println(Arrays.toString(arrs));
        arrs = Arrays.stream(arrs).boxed().sorted(((o1, o2) -> o2 - o1)).mapToInt(int1 -> int1).toArray();
        System.out.println(Arrays.toString(arrs));
        long endTime = System.currentTimeMillis();
        System.out.println("耗时:" + (endTime - startTime));

运行结果如下：

3.小结

1.这个问题的本质是如何将JAVA中int原子类型的数组内元素进行排序，由于Arrays类提供对包装类数组排序的自定义方法，因此可以借助Arrays类，前提是需要将int原子类型数组转换为Integer[]类型；
2.方案二与方案一原理一致，但从代码的优雅程度来说，方案一会明显优于方案二，且方案一的时间复杂度为O(n)，方案二的时间复杂度为O(n*n)，在数据量够大的情况下，方案一的运行速度会明显优于方案二；
3.方案四与方案五本质一致，实现方式不同，若数据量足够大，方案五的运行速度会远胜于方案四；方案四的空间复杂度为O(n)，牺牲了大量空间；
4.本文上述实现方案运行耗时取得是多次运算后最接近平均值的时间（运行内存：8G，处理器：AMD Ryzen 7 3700u with Radeon Vega Mobile Gfx2.30 GHz）。