二路归并排序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