二路归并排序java实现

二路归并排序：
其核心思想时将问题一分为二，并递归调用一分为二方法，使问题分割到不能再分各的原子问题，然后再归并，从实现原子问题开始，层层向上归并，最终解决整体问题。即所谓“分而治之，万流归一”

二路归并排序的时间复杂度计算如下：

参考资料：算法导论------递归算法的时间复杂度求解：

二路归并java实现：

public class MergeSort {
    
    public static void main(String[] args) {
        int [] array = {1,8,6,7,2,4,11,17,6,48,3};
        //int [] array ={9,8,7,6,5,4,3,2,1};
        int [] temp = new int [array.length];
        sort(array, temp, 0, array.length - 1);
        System.out.println("排序后：");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
    }
    /**
     * 总的sort循环。先将问题一分为二，再将问题解决后的两个子问题结果合并
     * 要想清楚 子数组 边界的处理。
     * 如子数组为 下标为(k,k + 1):则再分解为(K),(K+1)。
     * 如子数组下标为(k,k+1,k+2)：则分解为(k,k+1)和(k+2)。再递归调用分解(k,k+1)
     * @param array
     * @param temp
     * @param start
     * @param end
     */
    public static void sort (int [] array, int [] temp, int start, int end){
        if (start < end) {
            int mid = (start + end)/2;
            //解决左边子问题
            sort(array, temp, start, mid);
            //解决右边子问题
            sort(array, temp, mid + 1, end);
            //合并两个子问题
            merge(array,temp,start,end,mid);
        }
    }
    /**
     * 归并函数
     * @param array 原始数组
     * @param temp 辅助数组
     * @param start 归并开始坐标
     * @param end 归并结束坐标
     * @param mid = (start + end)/2
     */
    public static void merge(int[] array, int[] temp, int start, int end, int mid) {
        // TODO Auto-generated method stub
        //i：左子问题的操作下标； j：右子问题的操作下标
        int i = start;
        int j = mid + 1;
        int k = start;
        while (i <= mid && j <= end){
            if (array[i] < array[j]) {
                temp[k] = array[i];
                k++;
                i++;
            }else {
                temp[k] = array[j];
                k++;
                j++;
            }
        }    
        //左子数组还有元素
        while (i <= mid){
            temp[k] = array[i];
            k++;
            i++;
        }
        //右子数字还是元素
        while (j <= end){
            temp[k] = array[j];
            k++;
            j++;
        }

        //将辅助数组中排好序的元素复制到原数组
        //注意：辅助数组与原数组一一对应
        for (int index = start; index <= end; index ++){
            array[index] = temp[index];
            System.out.println("temp[" + index +"]" + "....." + temp[index]);
        }
        System.out.println("===============");
    }
}

通过控制台输出，我们可以看到排序的过程：

temp[0].....1
temp[1].....8
===============
temp[0].....1
temp[1].....6
temp[2].....8
===============
temp[3].....2
temp[4].....7
===============
temp[3].....2
temp[4].....4
temp[5].....7
===============
temp[0].....1
temp[1].....2
temp[2].....4
temp[3].....6
temp[4].....7
temp[5].....8
===============
temp[6].....11
temp[7].....17
===============
temp[6].....6
temp[7].....11
temp[8].....17
===============
temp[9].....3
temp[10].....48
===============
temp[6].....3
temp[7].....6
temp[8].....11
temp[9].....17
temp[10].....48
===============
temp[0].....1
temp[1].....2
temp[2].....3
temp[3].....4
temp[4].....6
temp[5].....6
temp[6].....7
temp[7].....8
temp[8].....11
temp[9].....17
temp[10].....48
===============
排序后：
1 2 3 4 6 6 7 8 11 17 48