排序算法之快速排序

基本原理

找出一个元素（理论上可以随便找一个）作为基准，通过一趟排序将要排序的数据分割成独立的两部分， 其中一部分的所有数据都比这个基准小，另外一部分的所有数据都比这个基准大，然后再按此方法对这 两部分数据分别进行快速排序，所以快速排序算法的核心算法就是分区操作，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

一趟快速排序算法

1. 设置两个变量i,j，排序开始的时候：i=0，j=N-1
2. 找一个基准比如以第一个数组元素作为关键数据，赋值给key，即key=A[0]
3. 从j开始向前搜索，即有后开始向前搜索（j- -），找到第一个小于key的值A[j]，将A[j]和A[i]互换
4. 从i开始向后搜索，即由前开始向后搜索（i++），找到第一个大于key的A[i]，将A[i]和A[j]互换
5. 重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时循环结束）

一趟快速排序图解

第一步：

首先设置两个变量i,j  并赋值i=0,j=arr.length - 1=5; 然后i和j各就各位，如下图所示

  随便找一个元素作为基准，这里取角标为0的数字6（吉利）为基准。赋值给key，即key=A[0]

一切准备就绪后，就开始查找了
从角标j开始向前搜索，arr[5]>arr[0](7>6),则j- -,只到找到第一个小于key
的值为止，即在角标为4上停止，然后key与arr[4]交换，如下图所示

第二步：

此时j的位置不动，角标i开始向后搜索（i++），只到找到第一个大于key的值为止， 即角标为2上停止，然后key与arr[2]交换，如下图

第三步：

此时i的位置不动，角标j开始向前搜索（j- -），只到找到第一个小于key的值为止，即角标为3上停止，然后key与arr[3]交换，如下图

第四步：

此时j的位置不动，角标i开始向后搜索（i++），只到找到第一个大于key的值为止， 嗯呦哎，i++后与j的值相同了，则循环结束。如下图

第一遍快速排序不会直接得到最终结果，但此时已经以基准key把数据分成两个部分，然后再分别对两个部分继续执行上述的步骤，再分解数组，直到不能再次分解为止。

代码实现

public class QuickSort {

    public static void main(String[] args) {
        int[] arr = {6, 5, 8, 4, 2, 7};
        quickSort(arr, 0, arr.length - 1);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }

    /**
     * 快速排序
     */
    public static void quickSort(int[] targetArr, int start, int end) {
        int left = start;
        int right = end;
        int key = targetArr[start];

        while (left < right) {
            //按j--方向遍历目标数组，直到比key小的值为止
            while (right > left && targetArr[right] >= key) {
                right--;
            }
            if (left < right) {
                //targetArr[left]已经保存在key中，可将后面的数填入
                targetArr[left] = targetArr[right];
                left++;
            }
            //按i++方向遍历目标数组，直到比key大的值为止
            while (left < right && targetArr[left] <= key) {
            //此处一定要小于等于零，假设数组之内有一亿个1，0交替出现的话，
            //而key的值又恰巧是1的话，那么这个小于等于的作用就会使下面的if语句少执行一亿次
                left++;
            }
            if (left < right) {
            //targetArr[right]已保存在targetArr[left]中，可将前面的值填入
                targetArr[right] = targetArr[left];
                right--;
            }
        }
        //此时left==right
        targetArr[left] = key;

        //递归调用，把key前面的完成排序
        if (left > start) {
            quickSort(targetArr, start, left - 1);
        }

        //递归调用，把key后面的完成排序
        if (right < end) {
            quickSort(targetArr, right + 1, end);
        }
    }
}

排序算法稳定性
快速排序是一个不稳定的排序算法
比如：序列为3 2 2 2，现在角标3元素会和角标0元素交换，此时就会把元素2的稳定性打乱。
快速排序的时间复杂度是O (nlogn)