归并排序之入门到"放弃"

前面我们已经讲解过了冒泡排序、选择排序、插入排序、 希尔排序。本次我们将讲解归并排序,希望大家学习完之后，能够徒手快速手写一个归并排序的实现代码。

由来

归并排序首先由著名的现代计算机之父 John_von_Neumann (冯·诺依曼)在 1945 年发明，被用在了 EDVAC(一台美国早期电子计算机)，足足用墨水写了 23 页的排序程序。

归并排序是一种分治策略的排序算法。它是一种比较特殊的排序算法，通过递归地先使每个子序列有序，再将两个有序的序列进行合并成一个有序的序列。

核心思想

归并排序(MERGE-SORT)是利用归并的思想实现的排序方法，该算法采用经典的分治(divide-and-conquer)策略(分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。

总体来说就是: “分”与“合”

主体流程

分而治之

可以看到这种结构很像一棵完全二叉树，本文的归并排序我们采用递归去实现(也可采用迭代的方式去实现)。分阶段可以理解为就是递归拆分子序列的过程，递归深度为log2n。

合并相邻有序子序列

再来看看治阶段，我们需要将两个已经有序的子序列合并成一个有序序列，比如上图中的最后一次合并，要将[4,5,7,8]和[1,2,3,6]两个已经有序的子序列，合并为最终序列[1,2,3,4,5,6,7,8]，来看下实现步骤。

具体的步骤可以总结为:

• 先申请一个辅助数组，长度等于两个有序数组长度的和。
• 从两个有序数组的第一位开始，比较两个元素，哪个数组的元素更小，那么该元素添加进辅助数组，然后该数组的元素变更为下一位，继续重复这个操作，直至数组没有元素。
• 返回辅助数组。

上述过程已经很详细了,但这里我们还是采用文字详细的描述一下相关过程:

有序数组A：[4, 5, 7, 8]有序数组B：[1, 2, 3, 6][] 表示比较的范围。

因为 1 有序数组A：[4, 5, 7, 8]有序数组B：1 [2, 3, 6] 辅助数组：1

因为 2 有序数组A：[4, 5, 7, 8]有序数组B：1 2 [3, 6]辅助数组：1 2

因为 3 有序数组A：[4, 5, 7, 8]有序数组B：1 2 3 [6]辅助数组：1 2 3

因为 4 有序数组A：4 [5, 7, 8]有序数组B：1 2 3 [6]辅助数组：1 2 3 4

因为 5 有序数组A：4 5 [7, 8]有序数组B：1 2 3 [6]辅助数组：1 2 3 4 5

因为 6 有序数组A：4 5 [7, 8]有序数组B：1 2 3 6 []辅助数组：1 2 3 4 5 6

因为数组B已经没有元素了,所以整个A右边序列移动过去,最终排序完成为：1 2 3 4 5 6 7 8

实现

按照上面的过程或者思路,我们可以写出主体伪代码:

# 归并排序中的思路MergeSort(arr[], l,  r)If r > l     1. 找到数组中的中间点，把数组分为两部分             middle m = (l+r)/2     2. 对数组的左部分调用MergeSort 函数               mergeSort(arr, l, m)     3. 对数组的右部分调用MergeSort 函数              mergeSort(arr, m+1, r)     4. 合并2,3中的两部分             merge(arr, l, m, r)

结合伪代码和上述的图解实例,我们可以写出具体的代码实现,下述是我实现的代码:

package sort

func MergeSort(array []int) { arrayLen := len(array) if arrayLen 1 {  panic("array len is less than 1") } start := 0 end := arrayLen - 1 mergeSort(array, start, end)}

func mergeSort(array []int, start int, end int) { if start >= end {  return } //找到数组中的中间点，把数组分为两部分 mid := (start + end) / 2 //对数组的左部分调用mergeSort 函数 mergeSort(array, start, mid) //对数组的右部分调用nergeSort 函数 mergeSort(array, mid+1, end) //合并数组的左右部分 merge(array, start, mid, end) return}

func merge(array []int, start int, mid int, end int) { // 申请一个辅助数组来合并两个有序数组，这两个数组是 array[start,mid],array[mid+1,end) tempArr := make([]int, 0, end-start+1) // 左数组移标 i := start // 右数组移标 j := mid + 1

 k := 0 // 两个数组开始比较 for ; i <= mid && j <= end; k++ {  if array[i] <= array[j] {   tempArr = append(tempArr, array[i])   i++  } else {   tempArr = append(tempArr, array[j])   j++  } }

 //剩余数组拼接 for ; i <= mid; i++ {  tempArr = append(tempArr, array[i]) }

 for ; j <= end; j++ {  tempArr = append(tempArr, array[j]) }

 // 将辅助数组的元素复制回原数组 for i, v := range tempArr {  array[start+i] = v } return}

时间复杂度

最优时间复杂度：O(n*log(n))

最坏时间复杂度：O(n*log(n))

平均时间复杂度：O(n*log(n))

空间复杂度

归并的空间复杂度就是那个临时的数组和递归时压入栈的数据占用的空间：n + logn；所以空间复杂度为: O(n)

稳定性

在分解的子列中，有1个或2个元素时，1个元素不会交换，2个元素如果大小相等也不会交换。在序列合并的过程中，如果两个当前元素相等时，我们把处在前面的序列的元素保存在结果序列的前面，所以，归并排序也是稳定的。

优化

这里就不展开详细的算法优化了,不过可以提供几种常见的思路就是:

• 当递归到规模足够小时，利用插入排序
• 归并前判断一下是否还有必要归并
• 只在排序前开辟一次空间

总结

归并排序是稳定排序，它也是一种十分高效的排序，能利用完全二叉树特性的排序一般性能都不会太差。它在时间上是非常有效的(最差时间复杂度和最优时间复杂度都为 O(nlogn)  )，但是这种算法很消耗空间，一般来说在内部排序不会用这种方法，而是用快速排序；外部排序才会考虑到使用这种方法；

参阅

图解排序算法(四)之归并排序