java递归——快速排序(效率最高)

案例代码第一种（比大部分快排写法效率高）

public static void main(String[] args) {
        int maxSize = 1000000;
        int [] arr = new int[maxSize];
        for(int i=0;i<maxSize;i++){
            Random random = new Random();
            arr[i] = random.nextInt(maxSize);
        }
        long startTime = System.currentTimeMillis();
        quickSort(arr, 0, arr.length - 1);
        long endTime = System.currentTimeMillis();
        long time = endTime - startTime;
        System.out.println(maxSize + "数据，快速排序耗时：" + time + "毫秒！");
//        System.err.println(ArrayUtil.toString(arr));
    }

    //排序
    protected static int[] quickSort(int[] arr, int left, int right) {
        if (left < right) {
            int partitionIndex = partition(arr, left, right);
            quickSort(arr, left, partitionIndex - 1);
            quickSort(arr, partitionIndex + 1, right);
        }
        return arr;
    }

    //根据基准值分区
    private static int partition(int[] arr, int left, int right) {
        System.err.println(ArrayUtil.toString(arr));
        // 设定基准值（pivot）
        int pivot = left;
        int index = pivot + 1;
        for (int i = index; i <= right; i++) {
            if (arr[i] < arr[pivot]) {
                swap(arr, i, index);
                index++;
            }
        }
        swap(arr, pivot, index - 1);
        return index - 1;
    }

    //比较交换
    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

案例代码第二种

public class AddServlet {
    public static void main(String[] args) {
        //（1）简单测试
//        int[] arr = {6,3,5,7,2,10,4,9,8,1};
//        quickSort(arr,0,arr.length - 1);
//        System.out.println(Arrays.toString(arr));

        //（2）构建百万随机数据测试
        int maxSize = 2000000;
        int [] arr = new int[maxSize];
        for(int i=0;i<maxSize;i++){
            Random random = new Random();
            arr[i] = random.nextInt(maxSize);
        }
        long startTime = System.currentTimeMillis();
        IntStream sorted = Arrays.stream(arr).sorted();
        quickSort(arr,0,arr.length - 1);
//        Arrays.sort(arr);
        long endTime = System.currentTimeMillis();
        long time = endTime - startTime;
        System.out.println(maxSize + "数据，快速排序耗时：" + time + "毫秒！");
//        System.out.println(Arrays.toString(arr)); //控制台输出信息不全，可以通过修改IDEA安装目录bin\idea.properties的idea.cycle.buffer.size参数大小
    }

    /**
     * 快速排序
     * @param arr 要排序的数组
     * @param start 起始元素位置
     * @param end 结束元素位置
     */
    public static void quickSort(int [] arr, int start, int end){
        //前奏：定义指针、变量、校验
        int left,//左指针
                right,//右指针
                temp,//临时变量
                k;//与基准值进行交换的位置
        if(start > end){//起始位置大于结束位置，说明排序已经完成，直接返回，可以防止数组越界问题
            return;
        }
        left = start;//将左指针默认设置为起始位置
        right = end;//将右指针默认设置为结束位置

        //第一部曲：定义基准值（这里为方便理解，以起始位置的值作为基准值）
        int stand = arr[start];

        //第二部曲：根据基准值划分数组为两部分（小于基准数的放在左边，大于基准数的放在右边）
        while(left < right){
            //从右边找到目标值（小于基准值）所在位置
            while(arr[right] >= stand && left < right){//如果元素大于等于基准值，并且左右位置还没相等，说明没找到目标值，需继续向前找（right--）
                right--;
            }
            //从左边找到目标值（大于基准值）所在位置
            while(arr[left] <= stand  && left < right){//如果元素小于等于基准值，并且左右位置还没相等，说明没找到目标值，需继续向后找（left++）
                left++;
            }
            //经过上面左右两边的while循环，表明左右两边都已经找到了目标元素所在位置，此时再交换左右两边目标位置的值
            if(left < right){
                temp = arr[right];
                arr[right] = arr[left];
                arr[left] = temp;
            }
        }
        //经过上面的while循环，表明已经走完了一轮交换，此时left和right位置是一样的，该位置就是k，取该位置的值与基准值所在位置的值进行交换
        k = left;
        arr[start] = arr[k];
        arr[k] = stand;
        //第三件部曲：最后对基准值所在位置左右两边的元素进行递归（最终完成左右两边的元素排序）
        quickSort(arr,start,k-1);
        quickSort(arr,k+1,end);
    }
}

重点：第一种优于第二种