排序与查找实例（四）：归并排序

    归并排序 简介:将两个（或两个以上）有序表合并成一个新的有序表即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列时间复杂度为O(nlogn) 稳定排序方式。具体实现如下：

    

/**  

 * @Title: MergeSort.java

 * @Package sortandsearch

 * @Description: TODO

 * @author peidong 

 * @date 2017-5-9 上午8:50:24

 * @version V1.0  

 */

packagesortandsearch;

 

/**

 * @ClassName: MergeSort

 * @Description: 归并排序实例

 * @date 2017-5-9 上午8:50:24

 *

 */

/*

 * 归并排序是一个分治算法。归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新

 * 的有序表，即把待排序序列分为若干个有序的子序列，再把有序的子序列合并为整体有序序列。 merg()

 * 函数是用来合并两个已有序的数组，是整个算法的关键。看下面的描述对 mergeSort函数的描述： MergeSort(arr[], l, r) If r

 * > l 1. 找到中间点，讲arr分为两部分:middle m = (l+r)/2 2. 对一部分调用mergeSort : Call

 * mergeSort(arr, l, m) 3.对第二部分调用mergeSort： Call mergeSort(arr, m+1, r) 4.

 * 合并这两部分: Call merge(arr, l, m, r)

 */

publicclass MergeSort {

 

       /**

        * 归并排序 简介:将两个（或两个以上）有序表合并成一个新的有序表

        * 即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列时间复杂度为O(nlogn) 稳定排序方式

        *

        *@param nums

        *           待排序数组

        *@return 输出有序数组

        */

       /**

        *

        *@Title: mergeSort

        *@Description: 归并排序,递归

        *@param nums

        *@param low

        *@param high

        *@return void

        *@throws

        */

       public static void mergeSort(int[] nums,int low, int high) {

              int mid = low +(high - low ) / 2;//可以避免溢出

              if (low < high) {

                     // 左边

                     mergeSort(nums, low, mid);

                     // 右边

                     mergeSort(nums, mid + 1,high);

                     // 左右归并

                     merge(nums, low, mid,high);

              }

       }

 

       /**

        *

       * @Title: merge

       * @Description: 合并數組

       * @param nums

       * @param low

       * @param mid

       * @param high   

       * @return void   

       * @throws

        */

       public static void merge(int[] nums, intlow, int mid, int high) {

              int[] temp = new int[high - low +1];

              int i = low;// 左指针

              int j = mid + 1;// 右指针

              int k = 0;

 

              // 把较小的数先移到新数组中

              while (i <= mid && j<= high) {  // = 不能省

                     if (nums[i] < nums[j]) {

                            temp[k++] =nums[i++];

                     } else {

                            temp[k++] =nums[j++];

                     }

              }

 

              // 把左边剩余的数移入数组

              while (i <= mid) {    // = 不能省

                     temp[k++] = nums[i++];

              }

 

              // 把右边边剩余的数移入数组

              while (j <= high) { // = 不能省

                     temp[k++] = nums[j++];

              }

 

              // 把新数组中的数覆盖nums数组

              for (int k2 = 0; k2 <temp.length; k2++) {

                     nums[k2 + low] = temp[k2];

              }

       }

 

       /**

        *

       * @Title: print

       * @Description: 打印數組

       * @param arr   

       * @return void   

       * @throws

        */

       public static void print(int[] arr) {

              for (int i = 0; i < arr.length;i++) {

                     System.out.print(arr[i] +" ");

              }

       }

 

       /**

        *@Title: main

        *@Description: 测试归并排序

        *@param args

        *@return void

        *@throws

        */

 

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              int[] arr = { 12, 11, 13, 5, 6, 7,3, 8, 2, 9 };

              System.out.println("原始数组为：");

              print(arr);

              System.out.println();

 

              int len = arr.length - 1;

              mergeSort(arr, 0, len);

 

              System.out.println("归并排序后的数组为");

              print(arr);

       }

 

}

 

时间复杂度：O(nlogn) 空间复杂度：O(n) 稳定排序