【数据结构与算法(Java)】排序-快速排序（交换排序）

1. 算法思路

快速排序是对 冒泡排序 的改进：

1. 找到中轴点pivot（中点）
2. pivot左右互相交换，使得：左边 < pivot，右边 > pivot
3. 对左边和右边数组分别重复上述步骤

2. 代码实现

    /**
     * 快速排序
     *      思路：
     *          step1:
     *              [ 8, 4, 2, <6>, 7, 1, 9, 3 ]
     *              left->    pivot      <-right
     *          step2:
     *              [ 3, 4, 2, 1, <6>, 7, 9, 8 ]
     *              0   <-right pivot left->   7
     *          step3:
     *              [ 3, 4, 2, 1 ] 和 [ 7, 9 ,8 ] 重复 step 1-3 （递归）
     *
     *          1. 找到中轴点pivot（中点）
     *          2. pivot左右互相交换，使得：左边 < pivot，右边 > pivot
     *          3. 对左边和右边数组分别重复上述步骤
     * @param array - 要排序的数组
     * @return - 排序后数组（不改变原始数组）
     */
    public static int[] quickSort(int[] array, int originalLeft, int originalRight) {
        // 复制数组
        int[] sortedArray = new int[array.length];
        for (int i = 0; i < array.length; i++) {
            sortedArray[i] = array[i];
        }

        // 设置中轴点pivot，用来分割数组
        int pivot = sortedArray[(originalLeft + originalRight) / 2];
        // 设置指针：left和right分别指向数组两端
        int left = originalLeft;
        int right = originalRight;
        // 若左指针<右指针，大循环：通过遍历分割数组，分别从左和从右两端寻找">pivot"和"<pivot"的值，找到后交换。当left不小于right时停止遍历
        while (left < right) {
            // 从左往右找">=pivot"的值，找到退出小循环
            while (sortedArray[left] < pivot) {
                left++;
            }
            // 从右往左找"<=pivot"的值，找到退出小循环
            while (sortedArray[right] > pivot) {
                right--;
            }
            // 若左指针>=右指针，说明pivot两端交换完成，退出循环
            if (left >= right) {
                break;
            }
            // 若左指针<右指针，交换找到的两个值
            int temp = sortedArray[left];
            sortedArray[left] = sortedArray[right];
            sortedArray[right] = temp;

            // 交换后，若左指针指向数值=pivot：右指针左移（防止无限循环）
            if (sortedArray[left] == pivot) {
                right--;
            }
            // 交换后，若右指针指向数值=pivot：左指针右移（防止无限循环）
            if (sortedArray[right] == pivot) {
                left++;
            }
        }

        // 结束交换后，左指针 >= 右指针
        // 若左指针=右指针：左指针右移，右指针左移（防止栈溢出）
        if (left == right) {
            left++;
            right--;
        }

        // 若数组左端<右指针：左递归
        if (originalLeft < right) {
            sortedArray = quickSort(sortedArray, originalLeft, right);
        }
        // 若数组右端>右指针：左递归右递归
        if (left < originalRight) {
            sortedArray = quickSort(sortedArray, left, originalRight);
        }

        // 返回排好序的数组
        return sortedArray;
    }