java实现归并排序

package recursion;

public class MergeSort {
    //1.首先将数组按照数组数组中间索引拆分成两个数组
    //2.不能在次拆分 及头 首索引相遇
    //3.依次向上合并

    public void mergeSort(int[] arr, int p, int r){
        if(p>=r){
            //数组拆分最少有一个节点时 结束
            return;
        }
        int q = p+(r-p)/2;
        mergeSort(arr, p, q);
        mergeSort(arr, q+1, r);
        //排序合并结果
        merge(arr, p, q, r);
    }

    public void merge(int[] arr, int p, int q, int r) {
        //创建两个拆分数组
        int[] left = new int[q-p+1+1];
        int[] right = new int[r-q+1];
        for(int i=0;i<q-p+1;i++){
            left[i] = arr[p+i];
        }
        for(int i=0;i<r-q;i++){
            right[i] = arr[q+i+1];
        }
        left[q-p+1] = Integer.MAX_VALUE;
        right[r-q] = Integer.MAX_VALUE;
        int i = 0;
        int j = 0;
        int k = p;
        while(k<=r){
            if(left[i]<=right[j]){
                arr[k++] = left[i++];
            }else{
                arr[k++] = right[j++];
            }
        }
    }


    public static void main(String[] args) {
        int[] arr = new int[]{12,1,19,4,17,10,1,1,6,7,15,4,3};
        MergeSort mergeSort = new MergeSort();
        mergeSort.mergeSort(arr,0, arr.length-1);
        for(int i=0; i<arr.length; i++){
            System.out.println(arr[i]);
        }
        System.out.println("执行结束");
    }
}

• 首先通过递归不断的按中间节点拆分数组，知道拆分成单个元素不能在拆分
• 从递归的最底层向上合并，每一次合并仅仅排序需要合并部分的元素
• 设置left和right的Integer.MAX_VALUE,是一种哨兵机制，这样写可以省略掉每次迭代left和right的边界检查，提高程序性能

空间复杂度:总计拆分log2 n 次，n为数组总大小，每次新建的空间为n，但是每次合并之后再进入下一次合并之前空间会被释放，空间复杂度只有O(n)
时间复杂度 拆分log2 n次，每次合并最大的排序时间复杂度不会超过n，所以时间复杂度最大为 nlog2 n