排序算法 - 归并排序

递归方式

基本思想

• 将数组分为左右两部分，分别进行递归排序
• 排好序的两部分进行合并
• 合并过程
  • 定义P1指针指向左部分最左边的值（最小值）
  • 定义P2指针指向右部分最左边的值（最小值）
  • 定义新数组，大小等于两部分的总大小
  • 比较P1和P2指针指向的值，当arr[P1]<=arr[P2]时，将arr[P1]加到新数组中，否则加入arr[P2]
  • 如果其中一部分的指针越界，那么将另一部分剩余元素加入新数组中
  • 将新数组赋给赋给入参数组的所在部分

代码

public class MergeSort {

    public static void process(int[] array,int L,int R){
        if (L==R){ //base case
            return;
        }

        //计算中点値
        int mid = L + ((R-L)>>1);
        //分别排好左边和右边，再合并
        process(array,L,mid);
        process(array,mid+1,R);

        //合并左右两边，有序
        merge(array,L,mid,R);
    }

    private static void merge(int[] array, int L, int mid, int R) {
        //定义p1指针，指向左部分左边界
        int p1 = L;
        //定义p2指针，指向右部分左边界
        int p2 = mid + 1;

        //定义同样长度的数组，记录排序后的值
        int[] arr = new int[R - L + 1];

        int i = 0;
        //判断p1，p2有没有越界
        while (p1 <= mid && p2 <= R) {
            //未越界则比较
            arr[i++] = array[p1] <= array[p2] ? array[p1++] : array[p2++];
        }

        //两个while只会发生一个，因为只会有其中一个越界
        //如果p1越界，则将p2后面的数都加入新数组
        while (p2 <= R) {
            arr[i++] = array[p2++];
        }
        //如果p2越界，则将p1后面的数都加入新数组
        while (p1 <= mid) {
            arr[i++] = array[p1++];
        }

        //将新数组赋给传入数组
        for (int j = 0; j < arr.length; j++) {
            array[L+j] = arr[j];
        }
    }

    public static void main(String[] args) {
        int[] array = new int[]{1,2,5,8,97,9,6,1};
        process(array,0,array.length-1);

        for (int a : array){
            System.out.println(a);
        }
    }
}

复杂度分析

• 符合Master公式：T(N) = 2T(N/2) + O(N) Master公式详解
• a=2，b=2，d=1
• 时间复杂度为O(N^d * logN) = O(N*logN)

非递归方式

基本思想

• 合并过程
• 合并组的大小指数增长：1,2,4,8,16…
• 定义mergeSize
  • 第1次mergeSize为1，即一组两个数合并
  • 第2次mergeSize为2，即一组四个数合并
  • mergeSize >= 数组长度， 停止
• 合并的方式同递归的合并

代码

public static void sort(int[] array){

    //数组判空
    if (array == null || array.length < 2){
        return;
    }

    //确定mergeSize的大小 mergeSize为当前有序的左组长度
    int mergeSize = 1; //初始时mergeSize为1

    //获取数组长度，用作结束条件
    int length = array.length;

    while (mergeSize < length){
        //定义第一个左组的左边界
        int L = 0;

        //各个左右组进行合并
        while (L < length){
            //寻找左组右边界
            int LR = L + mergeSize - 1;
            //判断左组右边界是否越界，如果越界则结束
            if (LR >= length){
                break;
            }
            //寻找其右组右边界
            //判断数组右边界和LR+mergeSize的大小，若LR+mergeSize超出右边界，则右边界为整个数组的右边界
            int R = Math.min(LR + mergeSize,length-1);

            //merge
            merge(array,L,LR,R);

            //寻找下一个左组左边界
            L = R + 1;
        }

        //防止越界（如果数组足够大，则mergeSize在达到一定规模（20亿）后，再*2会越界溢出，出险错误
        if (mergeSize > length/2){
            //如果mergeSize大于了一半的数组长度，那么下次*2后一定会大于length，即结束循环
            //提前判断，防止越界
            break;
        }

        //mergeSize增大(左移一位)
        mergeSize <<= 1;
    }
}

private static void merge(int[] array, int L, int mid, int R) {
     //定义p1指针，指向左部分左边界
     int p1 = L;
     //定义p2指针，指向右部分左边界
     int p2 = mid + 1;

     //定义同样长度的数组，记录排序后的值
     int[] arr = new int[R - L + 1];

     int i = 0;
     //判断p1，p2有没有越界
     while (p1 <= mid && p2 <= R) {
         //未越界则比较
         arr[i++] = array[p1] <= array[p2] ? array[p1++] : array[p2++];
     }

     //两个while只会发生一个，因为只会有其中一个越界
     //如果p1越界，则将p2后面的数都加入新数组
     while (p2 <= R) {
         arr[i++] = array[p2++];
     }
     //如果p2越界，则将p1后面的数都加入新数组
     while (p1 <= mid) {
         arr[i++] = array[p1++];
     }

     //将新数组赋给传入数组
     for (int j = 0; j < arr.length; j++) {
         array[L+j] = arr[j];
     }
 }

时间复杂度

外层的while循环执行了logN次，时间复杂度为O(logN)
内层的while循环时间复杂度为O(N)
所以非递归行为的时间复杂度为O(N*logN)