浅谈归并排序

浅谈冒泡排序
浅谈插入排序
浅谈选择排序
在之前的文章中介绍了三种时间复杂度为O(n²)的排序算法，由于时间复杂度比较高，所以这三种算法适合数据规模比较小的排序。为此接下来将会介绍两种时间复杂度为O(nlogn)的排序算法，归并排序和快速排序。这两种排序比较常见于大规模的数据排序中。今天这篇文章我们先来讲解归并排序。

一、归并排序的原理

归并排序的原理很好理解，它运用了分治的思想和递归方法的实现。首先把一个数组拆分成两部分，然后对这两部分运用递归的方法拆分成更小的两部分，直到不能拆分为更小的单元为止，拆分做完了，我们开始合并，将排好序的两部分依次合并在一起，最后整个数组就都有序了。具体的过程如下图所示。

在这里不少小伙伴可能会被分治和递归搞得云里雾里的，这里做一下说明分治是一种解决问题的思想，我们把一个大的问题拆分成为一个个更小的子问题，然后通过对子问题的求解，一步步得到最终大问题的解。而递归是分治思想的运用，即分治是抽象，递归是实现。
代码的实现包含两部分，分别是拆分和合并。拆分部分我们可以通过递归来实现，合并部分我们需要通过额外的空间来存储合并后的数据，然后运用双指针来实现两个部分的合并。
拆分的代码如下

// 递归调用函数
  //a是需要拆分的数组，p为数组中需要排序部分的起始位置，r为数组中需要排序部分的结束位置
  public static void split(int[] a, int p, int r) {
    // 递归终止条件
    if (p >= r) return;

    // 取p到r之间的中间位置q,防止（p+r）的和超过int类型最大值
    int q = p + (r - p)/2;
    // 分治递归
    mergeSortInternally(a, p, q);
    mergeSortInternally(a, q+1, r);
  }

合并部分的代码如下：

//a为要排序的数组，[p,q]和[q+1,r]为需要合并的两部分
  public static void merge(int[] a, int p, int q, int r) {
    //这里需要i、j两个指针指向数组的头位置
    int i = p;
    int j = q+1;
    int k = 0; // 初始化变量i, j, k
    int[] tmp = new int[r-p+1]; // 申请一个大小跟a[p...r]一样的临时数组
    while (i<=q && j<=r) {
      if (a[i] <= a[j]) {
        tmp[k++] = a[i++]; // i++等于i:=i+1
      } else {
        tmp[k++] = a[j++];
      }
    }

    // 判断哪个子数组中有剩余的数据
    int start = i;
    int end = q;
    if (j <= r) {
      start = j;
      end = r;
    }

    // 将剩余的数据拷贝到临时数组tmp
    while (start <= end) {
      tmp[k++] = a[start++];
    }

    // 将tmp中的数组拷贝回a[p...r]
    for (i = 0; i <= r-p; ++i) {
      a[p+i] = tmp[i];
    }
  }

二、归并排序的性能分析

第一、归并排序是稳定的排序算法吗？
从代码中我们可以看出，在数组拆分的阶段，并不涉及到元素位置的改变，所以判断排序算法是否稳定，我们要看合成阶段。

while (i<=q && j<=r) {
      if (a[i] <= a[j]) {
        tmp[k++] = a[i++]; // i++等于i:=i+1
      } else {
        tmp[k++] = a[j++];
      }
    }

从这段代码中我们可以看出，当a[i] = a[j]相等时，我们放入的是a[i]中的元素。而i指针所在的数组为两部分中的第一部分。所以保证了即使有相同的元素，元素的前后位置在合成之后也不会改变，即归并排序是一个稳定的排序算法。

第二、归并排序的时间复杂度是多少？

递归解决问题的思路就是一个问题a可以分解为多个子问题b、c，那求解问题a就可以分解为求解问题b、c,求解完b、c之后，我们在将b、c的结果合并，最后就得到了a的结果。
按同样的道理来求解时间复杂度，求解a问题的时间为T(a),求解子问题b、c的时间为T(b)、T©,于是可以得到以下的递推关系：

T(a) = T( b ) + T( c )+ k //k为合并所需要的常数级的时间

假设我们对n个元素进行排序所需要的时间是T(n)，那么求解两个子数组的时间都为T(n/2)。而从代码中我们看出合并两个数组的操作时间为O(n)。所以根据以上公式可以得出

T(1) = C; n = 1
T(n) = 2*T(n/2) + n; n > 1

根据递归一步一步往下展开的结果如下：

T(n) = 2*T(n/2) + n
= 2 * T(2 * T(n/4) + n/2) + n
= 2 * 2 * T(2 * T(n/8) + n/4) + 2 * n
= 2 * 2 * 2 * T(2 * T(n/16) + n/8) +3 * n
…
= 2 ^ k * T( n / 2 ^ k) + k * n
…

分解推导的结束条件是T(n / 2 ^ k) = T( 1 )，即 n / 2 ^ k = 1。得到 k = log2n。 将 k = log2n 带入上述公式后，我们得到 T( n ) = O( nlogn)。所以归并排序的时间复杂度为O(nlogn)。

第三、归并排序的空间复杂度是多少？

int[] tmp = new int[r-p+1]; // 申请一个大小跟a[p...r]一样的临时数组

从代码中看出，归并排序应用了一个额外的临时数组用于存放合并后的结果。所以归并排序的空间复杂度为O( n )。所以归并排序也并不是原地排序算法。