快速排序：基于二分法。

/**
 * @author chen-biao
 * @Date 2021/4/20 14:39
 */
public class Hello2 {


    public static void main(String[] args) throws Exception {
        int[] arr = {9, 1, 3, 9, 2, 9, 7, 8, 6, 4, 5, 0};
        System.out.println("原始数据:" + Arrays.toString(arr));
        //Arrays.sort(arr);
        maoPao(arr);
        chaRu(arr);
        kuaiSu(arr);

    }

    /**
     * 快速排序：分区，在分区内，大于基准值的放左边，小于基准值的放在右边。循环直至下标重合。
     * 1、适合递归
     * 2、基准值取数组头
     */
    public static void kuaiSu(int[] ap) {
        int[] arr = Arrays.copyOf(ap, ap.length);
        System.out.println("快速排序原始数据：" + Arrays.toString(arr));
        kuaiSuSortRecursion(arr, 0, arr.length - 1);
        System.out.println("快速排序结果：" + Arrays.toString(arr));
    }

    public static void kuaiSuSortRecursion(int[] arr, int lo, int hi) {
        if (lo >= hi) {
            return;
        }
        int i, j, x;
        i = lo;
        j = hi;
        x = arr[i]; //基准值
        while (i < j) {
            while (i < j && arr[j] > x) {
                j--; // 从右向左找第一个小于x的数
            }
            if (i < j) {
                arr[i++] = arr[j];
            }
            while (i < j && arr[i] < x) {
                i++; // 从左向右找第一个大于x的数
            }
            if (i < j) {
                arr[j--] = arr[i];
            }
            System.out.println("i:"+lo+","+Arrays.toString(arr));
        }
        arr[i] = x;
        kuaiSuSortRecursion(arr, lo, i - 1);
        kuaiSuSortRecursion(arr, i + 1, hi);
    }

    /**
     * 插入排序:现过程使用双层循环，外层循环对除了第一个元素之外的所有元素，(把第一个元素当作有序队列)
     * 内层循环对当前元素前面有序表进行待插入位置查找，并进行移动。
     * 1、把第一个元素当作有序队列，
     * 2、从第二个原始开始，在前面的有序队列中，查找插入的位置。
     * 3、有break，是因为循环的是有序队列，如果遇到不符合条件的，那么有序队列接下来的数据，都不符合条件。
     */
    public static void chaRu(int[] ap) {
        if (ap == null || ap.length < 1) {
            return;
        }
        int[] arr = Arrays.copyOf(ap, ap.length);
        System.out.println("插入排序原始数据：" + Arrays.toString(arr));
        int temp = 0;
        for (int i = 1; i < arr.length; i++) {
            for (int j = i; j > 0; j--) {
                if (arr[j] < arr[j - 1]) {
                    temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = temp;
                } else {
                    break;
                }
            }
            System.out.println("i:" + i + "," + Arrays.toString(arr));
        }
        System.out.println("插入排序结果：" + Arrays.toString(arr));
    }

    /**
     * 冒泡排序:实现方式为两层循环，首层循环确定比较的对象，内存循环跟比较对象对比，
     * 任意时候比较对象都是最大（最小）值，在比较过的元素中。
     * 1、首层确定最值对象。
     * 2、冒泡上去的，一定是最值。
     */
    public static void maoPao(int[] ap) {
        int[] arr = Arrays.copyOf(ap, ap.length);
        System.out.println("冒泡排序原始数据：" + Arrays.toString(arr));
        int temp = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    temp = arr[j];
                    arr[j] = arr[i];
                    arr[i] = temp;
                }
            }
            System.out.println("i:" + i + "," + Arrays.toString(arr));
        }
        System.out.println("冒泡排序结果：" + Arrays.toString(arr));
    }
}