算法与数据结构-快排

快排：

时间复杂度 ：

方式1.将数组最右边的数作为划分值进行划分， 划分为 (<=num) | (>num) 两个区域，然后将(>num)的第一个数和划分值进行交换，再将其左侧和右侧重复该行为。该方式每次确定一个数，时间复杂度O(N^2)
方式2.将数组最右边的数作为划分值进行划分，划分为 (<num) | (=num) | (>num) 三个区域，然后将(<num)和(>num)继续同样的操作，速度较方式1稍快，因为每次可以确定一组数。时间复杂度O(N^2)
方式3.随机选一个数作为划分值与最右边的数进行交换,然后重复方式2的过程。时间复杂度O(N*logN)

空间复杂度 ：

O(logN)，因为每次递归都需要一个值来记录划分位置

过程：

代码实现：

public class QuickSort {
    public static void quickSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        quickSort(arr, 0, arr.length - 1);
    }

    // 将arr[L...R]排好序
    public static void quickSort(int[] arr, int L, int R) {
        if (L < R) {
            // 随机选一个位置，把该位置的数和数组最右边数进行交换
            swap(arr, L + (int) (Math.random() * (R - L + 1)), R);
            int[] p = partition(arr, L, R);
            quickSort(arr, L, p[0] - 1); // 小于区域
            quickSort(arr, p[1] + 1, R); // 大于区域
        }
    }

    // 返回值是一个包含两个元素的数组，分别是等于区域的的左边界和右边界
    public static int[] partition(int[] arr, int L, int R) {
        int less = L - 1; // 小于区的右边界
        int more = R;  // 大于区的左边界(此时已经默认以arr[R]作为划分值)
        while (L < more) {  // L表示当前数的位置
            if (arr[L] < arr[R]) {  // 当前数 < 划分值
                swap(arr, ++less, L++);
            } else if (arr[L] > arr[R]) {  // 当前数 > 划分值
                swap(arr, --more, L);
            } else {
                L++;
            }
        }
        swap(arr, more, R);
        return new int[]{less + 1, more};
    }

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

tips:

方式1和2之所以时间复杂度是O(N^2), 是因为如果数组为[1,2,3,4,5]这样顺序的数组, 每次划分的左右部分极度不平衡, 是最差的情况,并且这种情况是可以人为设定的(即只要构造出这样的数组,时间复杂度一定为O(N^2)) 。最好的情况是两边分的数组长度一致,T(N)=2T(N/2)+O(N),O(N)为partition的时间复杂度,此时的时间复杂度为O(N*logN)
方式3因为是随机选的数,所以划分后好的情况和差的情况是等概率事件,经过数学推导后结果为O(N*logN)的时间复杂度