（单路，双路，三路）快速排序讲解及Java实现

快速排序（简称快排）：在待排序数组中确定一个基准值（pivot），一次排序后将所有小于基准值的数移动至基准值左侧，大于基准值的数据移动至基准值右侧，这样基准值所在的位置就是最终排序后其应在位置。根据分治、递归的思想，对左右两侧数据递归上面的操作，直至区间缩小为1，所有的数据就都有序了。

基准值的选取方法是很关键的（比如三元选取，随机选取等），但是并属于该篇博客的讲解范围，所以下面为了解释方便，基准值暂定的比较随意，大家谅解 ~

单路快排

核心思想：基准值定为最右边，i和j从最左边开始，如果j小于基准值，则i和j交换位置，并且i++，j++。否则i保持不动，j++。最终当j移动到基准值所在位置后，基准值与i交换位置。

下图中说明了一次排序的详细流程：

单路快排图示（*注：该图来自极客时间）

下面按照上述的规则列出一组数据整个交换流程：

单路排序数据交换流程

名词解释 -- 稳定性：经过某种排序算法之后，如果相同值的数据，前后顺序没有发生改变，我们就把这种算法叫做稳定的排序算法。

猜想一：基准值从最左边开始是否可以？

猜想一

得出结论：基准值必需是j移动的结尾，因为最终需要一次基准值和i的交换位置

代码实现：

    public static void quickSortSingle(int[] arr, int left, int right) {
        if (left > right)
            return;

        int pivot = arr[right];
        int i = 0, j = 0;
        while (j < right) {
            while (j < right && arr[j] <= pivot) {//如果"哨兵"j小于基准值，则"哨兵"i与"哨兵"j交换位置
                swap(arr, i, j);
                i++;
                j++;
            }
            j++;
        }
        //此时"哨兵"j移动到最右侧，基准值与哨兵"i"所在位置的值进行交换
        swap(arr, i, right);

        quickSortSingle(arr, left, i - 1);
        quickSortSingle(arr, i + 1, right);
    }

    private static void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

双路快排

核心思想：基准值在最左边，“哨兵”i在最左边，“哨兵”j在最右边，从右边（注意要从右边开始，下面会有说明）先开始（j--），如果“哨兵”j所在的数据小于基准值则停止；“哨兵”i开始（i++），如果“哨兵”i所在的数据大于基准值则停止，i与j交换位置；如果i和j相遇，则基准值与i或j（因为两者现在一致）交换位置。

下面按照上述的规则列出一组数据整个交换流程：

双路排序数据交换流程

猜想二：如果先从左边找会出现什么问题？

猜想二

得出结论：因为如果先从右边开始会停留在比基准值大的数上，这时交换基准值的位置就会出现问题，所以开始执行的方向必需是基准值的反方向。

代码实现：

    public static void quickSortDual(int[] arr, int left, int right) {
        if (left > right)
            return;

        int pivot = arr[left];//基准值
        int i = left;//左侧"哨兵"
        int j = right;//右侧"哨兵"
        while (i != j) {//注意：要从基准值所在侧的另外一侧开始
            while (arr[j] >= pivot && i < j)//如果右侧出现了比基准值小的元素，则"哨兵"j停留
                j--;
            while (arr[i] <= pivot && i < j)//如果左侧出现了比基准值小的元素，则"哨兵"i停留
                i++;
            if (i < j) {//如果"哨兵"i与j没有相遇则交换其所在位置的数据
                int tmp = arr[i];
                arr[i] = arr[j];
                arr[j] = tmp;
            }
        }
        //此时"哨兵"i与j相遇，交换基准值与该相遇点的数据
        arr[left] = arr[i];
        arr[i] = pivot;

        quickSortDual(arr, left, i - 1);//递归的处理左侧数据
        quickSortDual(arr, i + 1, right);//递归的处理右侧数据
    }

三路快排

核心思想：基准值在最左边，“哨兵”i在基准值右侧加1的位置，“哨兵”j在最右边，从基准值右侧加1的位置开始往后遍历，如果遍历到的当前值小于基准值，则当前值与左侧"哨兵"交换位置，左侧"哨兵"进一，反之，则当前值与右侧"哨兵"交换位置，左侧"哨兵"退一。

下面按照上述的规则列出一组数据整个交换流程（虽然该数据的排序过程并没有丢失稳定性，但是大家不要认为三路快排是个稳定排序算法）：

三路排序数据交换流程

代码实现：

    public static void quickSortThreeWay(int[] arr, int left, int right) {
        if (left > right)
            return;

        int pivot = arr[left];//基准值
        int i = left;//左侧"哨兵"
        int j = right + 1;//右侧"哨兵"
        int index = left + 1;
        while (index < j) {
            if (arr[index] < pivot) {//如果当前值小于基准值，则当前值与左侧"哨兵"交换位置，左侧"哨兵"进一
                swap(arr, index, i + 1);
                i++;
                index++;
            } else if (arr[index] > pivot) {//如果当前值大于基准值，则当前值与右侧"哨兵"交换位置，左侧"哨兵"退一
                swap(arr, index, j - 1);
                j--;
            } else {
                index++;
            }
        }

        swap(arr, left, i);

        quickSortSingle(arr, left, i - 1);
        quickSortSingle(arr, j, right);
    }

    private static void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }