用Java写算法之归并排序

转自；http://flyingcat2013.blog.51cto.com/7061638/1281026

 

前面的三种排序算法（冒泡排序，选择排序，插入排序）在平均情况下均为O(n^2)复杂度，在处理较大数据的时候比较吃力。现在来说说相对快速一些的算法，例如下面的归并排序。

 

算法概述/思路

归并排序是基于一种被称为“分治”（divide and conquer）的策略。其基本思路是这样的：

1.对于两个有序的数组，要将其合并为一个有序数组，我们可以很容易地写出如下代码：

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

//both a and b is ascend. public void merge( int [] a, int [] b, int [] c){      int i= 0 ,j= 0 ,k= 0 ;      while (i<=a.length && j<=b.length){          if (a[i]<=b[i]){              c[k++]=a[i++];          }          else {              c[k++]=b[j++];          }      }      while (i<=a.length){          c[k++]=a[i++];      }      while (j<=b.length){          c[k++]=b[j++];      } }

容易看出，这样的合并算法是高效的，其时间复杂度可达到O(n)。

2.假如有一个无序数组需要排序，但它的两个完全划分的子数组A和B分别有序，借助上述代码，我们也可以很容易实现；

3.那么，如果A,B无序，怎么办呢？可以把它们再分成更小的数组。

4.如此一直划分到最小，每个子数组都只有一个元素，则可以视为有序数组。

5.从这些最小的数组开始，逆着上面的步骤合并回去，整个数组就排好了。

总而言之，归并排序就是使用递归，先分解数组为子数组，再合并数组。

下面是归并排序的示意图（图片来自维基百科）：

代码实现

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

//归并排序      public static void mergeSort( int [] arr){          int [] temp = new int [arr.length];          internalMergeSort(arr, temp, 0 , arr.length- 1 );      }      private static void internalMergeSort( int [] a, int [] b, int left, int right){          //当left==right的时，已经不需要再划分了          if (left<right){              int middle = (left+right)/ 2 ;              internalMergeSort(a, b, left, middle);          //左子数组              internalMergeSort(a, b, middle+ 1 , right);       //右子数组              mergeSortedArray(a, b, left, middle, right);    //合并两个子数组          }      }      // 合并两个有序子序列 arr[left, ..., middle] 和 arr[middle+1, ..., right]。temp是辅助数组。      private static void mergeSortedArray( int arr[], int temp[], int left, int middle, int right){          int i=left;               int j=middle+ 1 ;          int k= 0 ;          while ( i<=middle && j<=right){              if (arr[i] <=arr[j]){                  temp[k++] = arr[i++];              }              else {                  temp[k++] = arr[j++];              }          }          while (i <=middle){              temp[k++] = arr[i++];          }          while ( j<=right){              temp[k++] = arr[j++];          }          //把数据复制回原数组          for (i= 0 ; i<k; ++i){              arr[left+i] = temp[i];          }      }

需要说明的是，在合并数组的时候需要一个temp数组。我们当然有足够的理由在每次调用的时候重新new一个数组（例如，减少一个参数），但是，注意到多次的创建数组对象会造成额外的开销，我们可以在开始就创建一个足够大的数组（等于原数组长度就行），以后都使用这个数组。实际上，上面的代码就是这么写的。

 

算法性能/复杂度

归并排序的效率是很高的，由于递归划分为子序列只需要logN复杂度，而合并每两个子序列需要大约2n次赋值，为O(n)复杂度，因此，只需要简单相乘即可得到归并排序的时间复杂度 O(㏒n)。并且由于归并算法是固定的，不受输入数据影响，所以它在最好、最坏、平均情况下表现几乎相同，均为O(㏒n)。

但是，归并排序最大的缺陷在于其空间复杂度。从上面的代码可以看到，在合并子数组的时候需要一个辅助数组，然后再把这个数据拷贝回原数组。所以，归并排序的空间复杂度（额外空间）为O(n)。可不可以省略这个数组呢？不行!如果取消辅助数组而又要保证原来的数组中数据不被覆盖，那就必须要在数组中花费大量时间来移动数据。不仅容易出错，还降低了效率。因此这个辅助空间是少不掉的。

 

算法稳定性

因为我们在遇到相等的数据的时候必然是按顺序“抄写”到辅助数组上的，所以，归并排序同样是稳定算法。

 

算法适用场景

归并排序在数据量比较大的时候也有较为出色的表现（效率上），但是，其空间复杂度O(n)使得在数据量特别大的时候（例如，1千万数据）几乎不可接受。而且，考虑到有的机器内存本身就比较小，因此，采用归并排序一定要注意。

转载于:https://www.cnblogs.com/shz365/p/6156142.html