3归并排序与随机快排

归并排序

O(Nlog(N))

//递归方法实现
    public static void mergeSort1(int[] arr){
        if(arr == null || arr.length < 2){
            return;
        }
        process(arr,0,arr.length - 1);
    }

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

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

 //非递归方法实现
    public static void mergeSort2(int[] arr){
        if(arr == null || arr.length < 2){
            return;
        }
        int N = arr.length;
        int mergeSize = 1;
        while(mergeSize < N){
            int L = 0;
            while(L < N){
                int M = L + mergeSize - 1;
                if(M >= N){
                    break;
                }
                int R = Math.min(M + mergeSize,N - 1);
                merge(arr,L,M,R);
                L = R + 1;
            }
            if(mergeSize > N / 2){
                break;
            }
            mergeSize <<= 1;
        }
    }

小和问题：数组中每个元素的左边数字比自身小的所有数字之和为该元素的小和，所有元素的小和求和得到数组的小和。

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

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

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

快速排序

分区问题：给定一个数组和一个整数，把小于等于该整数的数放在数组左边，其他放在右边。

//以arr[R]划分
public static int[] netherlandsFlag(int[] arr,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(arr[index] == arr[R]){
            index++;
        }else if(arr[index] < arr[R]){
            swap(arr,index++,++less);
        }else{
            swap(arr,index,--more);
        }
    }
    swap(arr,more,R);
    return new int[]{less + 1,more};
}

//快排
public static void quickSort1(int[] arr){
        if(arr == null || arr.length < 2){
            return;
        }
        process1(arr,0,arr.length - 1);
    }

    private static void process1(int[] arr, int L, int R) {
        if(L >= R){
            return;
        }
       // swap(arr,L + (int)(Math.random() * (R - L + 1)),R);   （*）
        int[] equalArea = netherlandsFlag(arr,L,R);
        process1(arr,L,equalArea[0] - 1);
        process1(arr,equalArea[1] + 1,R);
    }

算法在没有（*）语句时，最差时间时间复杂度为O(N^2)的，添加随机语句后，算法复杂度期望为O(Nlog(N)) 。