经典排序之快速排序

1，基本思想：

快速排序（Quicksort）是对冒泡排序算法的一种改进。

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

2，实现步骤

1. 先寻找出一个基准值，理论上基准值可以是待排序数中的任意一个值，此处我们取基准值采取的方法是寻找数组最中间的数充当基准值

2. 创建两个索引

   左索引：初始值为待排序数组的最左端，不断右移，直至找到大于或等于基准值的数，跳出循环与右所引所指向的数交换

   右索引：初始值为待排序数组的最右端，不断左移，直至找到小于或等于基准值的数，跳出循环与左所引所指向的数交换

3. 当左索引小于右索引时，循环继续执行2步骤；否则这一趟排序已经完成跳出循环。

4. 分别向左右递归重复（1-3）

3，代码实现

public static void main(String[] args) {
    int[] arr = {3, 6, 1, 8, 3, 0, 12};
    int[] newArr = sort(arr, 0, arr.length - 1);
    System.out.println(Arrays.toString(newArr));
}

//快速排序

/**
 * @param arr:待排序数组
 * @param left：待排序数组的左索引，初始指向数组的最左端不断右移，
 * @param right：待排序数组的右索引，初始值指向数组的最右端不断左移
 * @return：返回排好顺序的数组
 */
public static int[] sort(int[] arr, int left, int right) {
    int l = left;//左边的指针，不断右移
    int r = right;//右边的指针，不断左移
    int middle = arr[(l + r) / 2];//基准值取中间的数值；注意，此处的基准值值不变，但位置是可能发生改变的
    while (l < r) {//进入循环，进行基准值左右两边的数值交换成左边的都小于基准值，右边的都大于基准值的情况的操作
        while (arr[l] < middle) {//不断右移左边的指针，直至找出大于或等于基准值的值
            l++;
        }
        while (arr[r] > middle) {//不断左移右边的指针，直至找出小于于或等于基准值的值
            r--;
        }
        /**
         * 此处用来跳出循环
         * 如果左指针大于等于右边的指针时
         * 则基准值左右两边的值已经筛选交换完毕，
         * 以基准值为界限，左边的都小于基准值，右边的都大于基准值
         * 此时一次排列已经完成，之后开始对其左右分别以同样的方式进行递归
         */
        //l>r说明左边的都比middle小 右边都大
        if (l >= r) {
            break;
        }
        //左右两边分别找出小于等于或大于等于基准值的值进行交换,把l给r,或者r给l
        arr[l] = arr[l] ^ arr[r];
        arr[r] = arr[r] ^ arr[l];
        arr[l] = arr[l] ^ arr[r];
        //此处为了防止数组中出现与基准值重复的数据，
        //arr[l]=arr[r]=middle;左或右必须有一方跳过一个middle值,否则将会产生死循环
        // （自我感觉此处有可能会出现偷梁换柱行为，基准值可能会变成另一个middle，虽然结果是不影响，但造成了不稳定）
        //例如： int[] arr={2,1,1,0,4} 在以1为基准进行第一次操作时，当进行到l=1,r=2时，会产生死循环；这两处的值将不断进行交换无法跳出
        if (arr[l] == middle) {
            r--;
        }
        if (arr[r] == middle) {
            l++;
        }
    }
    /**
     * 跳出循环后的l和r都是指向基准值时
     * 此时基准值的相对位置已经找好，可以不再对其基准值进行操作，所以l+1;r-1;
     *这一操作也是为了防止栈溢出，当出现new arr[]{0,1}这样的数组，基准值为0，将会产生死龟，无限向右递归
     *产生死龟原因： new arr[]{0,1}，每次循环操作出来后r=l=0;left=0,right=1;故满足向右递归的条件，将无限递归下去。
     */
    if (l == r) {
        l++;
        r--;
    }

    //进行左部分递归操作
    if (left < r) {
        sort(arr, left, r);
    }
    //进行右部分递归操作
    if (l < right) {
        sort(arr, l, right);
    }
    return arr;
}

4，复杂度于稳定性分析

稳定性：若数组中出现重复元素，若排序后重复元素还按照源数组中的先后顺序排列，则称之为稳定，否则为不稳定

in-place：不占用额外内存

n：数据规模

排序算法	平均时间复杂度	最好情况	最坏情况	空间复杂度	排序方式	稳定性
快速排序	O（n log n）	O（n log n）	O(n^2)	O(log n)	In-place	不稳定