快速排序算法

参考：算法 3：最常用的排序——快速排序
【漫画】不要再问我快速排序了

快排的核心思想就是指定一个主元，通过比较和遍历之后将主元归位；
主元归位之后情况就是：主元的左边都是小于主元的元素，主元的右边都是大于或等于主元的元素，然后继续对主元两边的子数组进行主元归位操作，最后达到一个排序的效果。

方法 1：单向扫描

public class QuickSort {
    private static int partition(int[] arr, int left, int right) {
        // 以第一个数作为主元
        int pivot = arr[left];
        int i = left;
        for (int j = left + 1; j <= right; j++) {
            // 比主元小，交换元素，让 i 指向比主元小的数
            if (arr[j] < pivot) {
                i++;
                int temp = arr[j];
                arr[j] = arr[i];
                arr[i] = temp;
            }
        }
        // i 指向的数小于或等于主元（等于主元的情况是 i 一直是 left 的位置，
        // 这种情况下是最坏的情况，时间复杂度将是 n^2）
        arr[left] = arr[i];
        arr[i] = pivot;
        return i;
    }

    private static void quickSort(int[] arr, int left, int right) {
        if (left < right) {
            int pos = partition(arr, left, right);
            quickSort(arr, left, pos - 1);
            quickSort(arr, pos + 1, right);
        }
    }

    public static void main(String[] args) {
        int[] data = new int[]{10, 3, 7, 9, 2, 8, 20};
        quickSort(data, 0, data.length - 1);
        System.out.println(Arrays.toString(data));
    }
}

方法2：双向扫描

public class QuickSort2 {
    private static int partition(int[] arr, int left, int right) {
        // 第一个元素充当主元
        int pivot = arr[left];
        // i 的目标是找出大于主元的元素
        // j 的目标是找出小于主元的元素
        int i = left, j = right;
        // i 和 j 双向移动
        while (i < j) {
            /* 这一步一定要先出发，不然在主元归位的时候会出错：
             * 比如当数组是 {1, 2} 的时候，如果是 i 先向右遍历，
             * 会执行 i++，然后从 0 变成了 1，主元归位就会出错
             */ 
            // j 向左遍历的过程中，遇到小于主元的时候停止移动
            while (i < j && arr[j] >= pivot) {
                j--;
            }
            // i 向右遍历的过程中，遇到大于主元的时候停止移动
            while (i < j && arr[i] <= pivot) {
                i++;
            }

            if (i < j) {
                // 将两个元素进行交换
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        // i 指向的元素是小于或等于主元的元素
        // 主元归位
        /* 如果数组是 arr = {4, 3, 2, 4, 5}
         * 第一轮遍历后，i 和 j 都指向 arr[3]（值是4，和主元相同），
         * 然后主元归位时，arr[left] 和 arr[i] 交换：
         * arr[left] = arr[i];
         * arr[i] = pivot; 
         * 这样 arr[0] 和 arr[3]（它们元素相同） 就交换了，
         * 从而说快排不是一种稳定的排序，因为排序的过程中会改变元素的顺序
         */
        arr[left] = arr[i];
        arr[i] = pivot;
        return i;
    }

    private static void quickSort(int[] arr, int left, int right) {
        if (left < right) {
            int pos = partition(arr, left, right);
            quickSort(arr, left, pos - 1);
            quickSort(arr, pos + 1, right);
        }
    }

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