归并排序 详解

Posted 2021-03-06 shona

• 时间复杂度：O(nlogn)
• 空间复杂度：O(N)，归并排序需要一个与原数组相同长度的数组做辅助来排序
• 稳定性：归并排序是稳定的排序算法，temp[i++] = arr[p1] <= arr[p2] ? arr[p1++] : arr[p2++];这行代码可以保证当左右两部分的值相等的时候，先复制左边的值，这样可以保证值相等的时候两个元素的相对位置不变。

 

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。把长度为n的输入序列分成两个长度为n/2的子序列；对这两个子序列分别采用归并排序；将两个排序好的子序列合并成一个最终的排序序列。

从下图可以看出，每次合并操作的平均时间复杂度为O(n)，而完全二叉树的深度为|log2n|。总的平均时间复杂度为O(nlogn)。而且，归并排序的最好，最坏，平均时间复杂度均为O(nlogn)。

 

 

 

图示过程

(1) 归并排序的流程

 

(2) 合并两个有序数组的流程

 

 

 

 

归并排序有两种实现方式： 基于递归的归并排序和基于循环的归并排序。（也叫自顶向下的归并排序和自底向上的归并排序）

这两种归并算法虽然实现方式不同，但还是有共同之处的：

1. 无论是基于递归还是循环的归并排序， 它们调用的核心方法都是相同的：完成一趟合并的算法，即两个已经有序的数组序列合并成一个更大的有序数组序列 （前提是两个原序列都是有序的！）

2. 从排序轨迹上看，合并序列的长度都是从小（一个元素）到大（整个数组）增长的

 

C++

一、基于递归的归并排序（自顶向下的归并排序）

void MergeSort (int arr [], int low,int high) {
    if(low>=high) { return; } // 终止递归的条件，子序列长度为1
    int mid =  low + (high - low)/2;  // 取得序列中间的元素
    MergeSort(arr,low,mid);  // 对左半边递归
    MergeSort(arr,mid+1,high);  // 对右半边递归
    merge(arr,low,mid,high);  // 合并
  }


void merge(int arr[],int low,int mid,int high){
    //low为第1有序区的第1个元素，i指向第1个元素, mid为第1有序区的最后1个元素
    int i=low, j=mid+1, k=0;  //mid+1为第2有序区第1个元素，j指向第1个元素
    int *temp=new int[high-low+1]; //temp数组暂存合并的有序序列
    while(i<=mid&&j<=high){
        if(arr[i]<=arr[j]) //较小的先存入temp中
            temp[k++]=arr[i++];
        else
            temp[k++]=arr[j++];
    }
    while(i<=mid)//若比较完之后，第一个有序区仍有剩余，则直接复制到t数组中
        temp[k++]=arr[i++];
    while(j<=high)//同上
        temp[k++]=arr[j++];
    for(i=low,k=0;i<=high;i++,k++)//将排好序的存回arr中low到high这区间
    　　arr[i]=temp[k];
    delete []temp;//释放内存，由于指向的是数组，必须用delete []
}

 

基于递归归并排序的优化方法

优化一：对小规模子数组使用插入排序

用不同的方法处理小规模问题能改进大多数递归算法的性能，因为递归会使小规模问题中方法调用太过频繁，所以改进对它们的处理方法就能改进整个算法。因为插入排序非常简单， 因此一般来说在小数组上比归并排序更快。 这种优化能使归并排序的运行时间缩短10%到15%。

怎么切换呢?只要把作为停止递归条件的

  if(low>=high) { return; }

改成

 if(high - low <= 10) { // 数组长度小于10的时候
      InsertSort(int arr[], int low,int high) // 切换到插入排序
      return;
 }

就可以了，这样的话，这条语句就具有了两个功能：

1. 在适当时候终止递归

2. 当数组长度小于M的时候（high-low <= M）， 不进行归并排序，而进行插排

 

优化二: 测试待排序序列中左右半边是否已有序

通过测试待排序序列中左右半边是否已经有序， 在有序的情况下避免合并方法的调用。

因为a[low...mid]和a[mid...high]本来就是有序的，存在a[low]<a[low+1]...<a[mid]和a[mid+1]<a[mid+2]...< a[high]这两种关系， 如果判断出a[mid]<=a[mid+1]的话，我们就认为数组已经是有序的并跳过merge() 方法。

void sort (int a[], int low,int high) {
    if(low>=high) {
      return;
    } // 终止递归的条件
    int mid =  low + (high - low)/2;  // 取得序列中间的元素
    sort(a,low,mid);  // 对左半边递归
    sort(a,mid+1,high);  // 对右半边递归
    if(a[mid]<=a[mid+1]) return; // 避免不必要的归并
    merge(a,low,mid,high);  // 单趟合并
  }

优化三：去除原数组序列到辅助数组的拷贝

在上面介绍的基于递归的归并排序的代码中， 我们在每次调用merge方法时候，我们都把arr对应的序列拷贝到辅助数组temp中去。

在递归调用的每个层次交换输入数组和输出数组的角色，从而不断地把输入数组排序到辅助数组，再将数据从辅助数组排序到输入数组，节省数组复制的时间。

注意， 外部的sort方法和内部sort方法接收的a和aux参数刚好是相反的

 

在这里我们做了两个操作：

• 在排序前拷贝一个和原数组元素完全一样的辅助数组（不再是创建一个空数组了！）
• 在递归调用的每个层次交换输入数组和输出数组的角色

因为外部sort和merge的参数顺序是相同的，所以，无论递归过程中辅助数组和原数组的角色如何替换，对最后一次调用的merge而言（将整个数组左右半边合为有序的操作）， 最终被排为有序的都是原数组，而不是辅助数组！

void MergeSortCore(int* data, int* copy, int first, int last);
void MergeSort(int* data, int length)
{
    if(data == NULL || length <= 0) return;
 
    int* copy = new int[length];
    for(int i = 0; i < length; i++)
        copy[i] = data[i];
 
    MergeSortCore(data, copy, 0, length - 1);
 
    for(int i = 0; i < length; i++)
        data[i] = copy[i];
    delete[] copy;
    return;
}
 
void MergeSortCore(int* data, int* copy, int first, int last)
{
    if(first == last)
        copy[first] = data[first];
    else
    {
        int mid = first + (last - first)/2;
        MergeSortCore(copy, data, first, mid);
        MergeSortCore(copy, data, mid + 1, last);
 
        //merge    
        int i = first, j = mid + 1;
        int k = first;
        while(i <= mid && j <= last)
        {
            if(data[i] <= data[j]) copy[k++] = data[i++];
            else copy[k++] = data[j++];
        }
 
        while(i <= mid) copy[k++] = data[i++];
        while(j <= last) copy[k++] = data[j++];
    }
}

 

注意：优化结果虽然差不多，但是当其数组接近有序的时候，速度有了可观的提升。

 

 

 

二、基于循环的归并排序（自底向上）

void sort(int a []){
    int N = a.size();
    for (int size = 1; size < N; size *= 2){
      //  low+size=mid+1,为第二个分区第一个元素，它 < N，确保最后一次合并有2个区间
      for(int low = 0; low + size < N;low += 2 * size) {
        mid = low + size - 1;
        high = low + 2 * size - 1;
        if(high > N-1) high = N - 1;
        merge(a,low, mid, high);
      }
    }
  }

 

 

 

参考