算法二期：归并 快排

一、归并

	private static void merge(int[] a, int L, int M, int R) {
        int[] tmp = new int[R - L + 1];
        int i = 0;
        int p1 = L;
        int p2 = M + 1;
        while (p1 <= M && p2 <= R) {
            tmp[i ++] = a[p1] <= a[p2] ? a[p1 ++] : a[p2 ++];
        }
        while (p1 <= M) {
            tmp[i ++] = a[p1 ++];
        }
        while (p2 <= R) {
            tmp[i ++] = a[p2 ++];
        }
        for (i = 0; i < tmp.length; i ++) {
            a[L + i] = tmp[i];
        }
    }

    private static void process(int[] a, int L, int R) {
        if (L >= R)
            return;
        int mid = L + ((R - L) >> 1);
        process(a, L, mid);
        process(a, mid + 1, R);
        merge(a, L, mid, R);
    }

    private static void mergeSort1(int[] a) {
        process(a, 0, a.length - 1);
    }

二、快排

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

    private static int partition(int[] a, int L, int R) {
        if (L > R)
            return -1;
        if (L == R)
            return L;
        int less = L - 1;
        int index = L;
        while (index < R) {
            if (a[index] <= a[R]) {
                swap(a, index, ++ less);
            }
            index ++;
        }
        swap(a, ++ less, R);
        return less;
    }

    private static void process(int[] a, int L, int R) {
        if (L >= R)
            return;
        int mid = partition(a, L, R);
        process(a, L, mid - 1);
        process(a, mid + 1, R);
    }

    private static void quickSort(int[] a) {
        process(a, 0, a.length - 1);
    }

三、快排 荷兰国旗

    private static int[] nf(int[] a, int L, int R) {
        if (L > R)
            return new int[] {-1, -1};
        if (L == R)
            return new int[] {L, R};
        int less = L - 1;
        int more = R;
        int index = L;
        while (index < more) {
            if (a[index] == a[R]) {
                index ++;
            } else if (a[index] < a[R]) {
                swap(a, index ++, ++ less);
            } else {
                swap(a, index, -- more);
            }
        }
        swap(a, more, R);
        return new int[] {less + 1, more};
    }

    private static void process(int[] a, int L, int R) {
        if (L >= R)
            return;
        int[] equalsArea = nf(a, L, R);
        process(a, L, equalsArea[0] - 1);
        process(a, equalsArea[1] + 1, R);
    }

    private static void quickSort(int[] a) {
        process(a, 0, a.length - 1);
    }