归并排序(Mergesort)

归并排序是基于分治策略的一种排序算法。

归并排序

基本思想是：将待排序的元素分成大小大致相同的两个子集合，分别对两个字集合进行排序，最终将排好序的子集合序列合并成要求的排好序集合。

• 合并算法可递归描述如下：

template<class Type>
void MergeSort(Type a[], int left, int right){
    if(left < right){
        int i = (right - left) / 2 + left; // 取中点
        MergeSort(a, left, i);
        MergeSort(a, i + 1, right);
        Merge(a, b, left, i, right); // 合并到数组b
        copy(a, b, left, right); // 复制回数组a
    }
}

• 合并的算法具体描述如下：

template<class Type>
void Merge(Type a[], Type b[], int left, int mid, int right){
    int i = left, j = mid + 1, k = left;
    while(i <= mid && j <= right){
        if(a[i] <= a[j]){
            b[k++] = a[i++];
        }else{
            b[k++] = a[j++];
        }
    } 
    while(i <= mid){
        b[k++] = a[i++];
    }
    while(j <= right){
        b[k++] = a[j++];
    }
    for(int q = left; q <= right; q++){
        a[q] = b[q];
    }
}

• 复制数组：

template<class Type>
void copy(Type a[], Type b[], int left, int right){
    for(int i = left; i <= right; i ++){
        a[i] = b[i];
    }
}

练习题（点我）

AC代码

#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
int a[MAX]; 
int b[MAX];
template<class Type>
void Merge(Type a[], Type b[], int left, int mid, int right){
    int i = left, j = mid + 1, k = left;
    while(i <= mid && j <= right){
        if(a[i] <= a[j]){
            b[k++] = a[i++];
        }else{
            b[k++] = a[j++];
        }
    } 
    while(i <= mid){
        b[k++] = a[i++];
    }
    while(j <= right){
        b[k++] = a[j++];
    }
    for(int q = left; q <= right; q++){
        a[q] = b[q];
    }
}

template<class Type>
void Copy(Type a[], Type b[], int left, int right){
    for(int i = left; i <= right; i ++){
        a[i] = b[i];
    }
}
template<class Type>
void MergeSort(Type a[], int left, int right){
    if(left < right){
        int i = (right - left) / 2 + left; // 取中点
        MergeSort(a, left, i);
        MergeSort(a, i + 1, right);
        Merge(a, b, left, i, right); // 合并到数组b
        Copy(a, b, left, right); // 复制回数组a
    }
}
int main(){
    int n;
    cin >> n;
    for(int i = 0; i < n; i++){
        cin>>a[i];
    }
    
    MergeSort(a, 0, n-1);
    
    for(int i = 0; i < n; i++){
        cout << a[i] << endl;
    }
    system("pause");
    return 0;
}

T(n)的计算

显然在计算中，Merge和Copy函数均在O(n)时间内完成，因此归并排序算法对n个元素进行排序，在最坏的情况下所需要的计算时间T(n)满足：

解次递归方程可得T(n) = O(nlogn)。

归并排序改进版

对于归并排序，从分治策略入手，容易消除算法中的递归。可以先将数组a中的相邻元素两两配对。用归并算法将他们排序，构成n/2组长度为二的子数组，在进一步合并，知道数组排好序。

• 消去递归的合并排序算法如下：

template<class Type>
void MergeSort(Type a[], int n){
    int s = 1;
    while(s < n){
        MergePass(a, b, s, n); // 合并到数组b
        s += s;
        MergePass(b, a, s, n); // 合并到数组a
        s += s;
    }
}

• 函数MergePass()用于合并排好序的相邻数组段。

template<class Type>
void MergePass(Type a[], Type b[], int s, int n){
    int i = 0;
    while(i <= n - 2 * s){
        Merge(a, b, i, i + s - 1, i + 2 * s - 1); // 合并大小为s的相邻2段子数组
        i = i + 2 * s;
    }
    if(s + i < n){
        Merge(a, b, i, i + s - 1, n - 1);
    }else{
        for(int j = i; j <= n - 1; j ++){
            b[j] = a[j];
        }
    }
}

• 具体的合并算法由Merge()函数来实现

template<class Type>
void Merge(Type a[], Type b[], int left, int mid, int right){
    int i = left, j = mid + 1, k = left;
    while(i <= mid && j <= right){
        if(a[i] <= a[j]){
            b[k++] = a[i++];
        }else{
            b[k++] = a[j++];
        }
        if(i > mid){
            for(int q = j; q <= right; q++){
                b[k++] = a[q];
            }
        }else{
            for(int q = i; q <= mid; q++){
                b[k++] = a[q];
            }
        }
    } 
}

归并排序练习题.

ac代码

#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
int a[MAX]; 
int b[MAX];

template<class Type>
void Merge(Type a[], Type b[], int left, int mid, int right){
    int i = left, j = mid + 1, k = left;
    while(i <= mid && j <= right){
        if(a[i] <= a[j]){
            b[k++] = a[i++];
        }else{
            b[k++] = a[j++];
        }
    } 
    while(i <= mid){
        b[k++] = a[i++];
    }
    while(j <= right){
        b[k++] = a[j++];
    }
    for(int q = left; q <= right; q++){
        a[q] = b[q];
    }
}

template<class Type>
void MergePass(Type x[], Type y[], int s, int n){
    int i = 0;
    while(i <= n - 2 * s){
        Merge(x, y, i, i + s - 1, i + 2 * s - 1); // 合并大小为s的相邻2段子数组
        i = i + 2 * s;
    }
    if(s + i < n){
        Merge(x, y, i, i + s - 1, n - 1);
    }else{
        for(int j = i; j <= n - 1; j ++){
            y[j] = x[j];
        }
    }
}

template<class Type>
void MergeSort(Type a[], int n){
    int s = 1;
    while(s < n){
        MergePass(a, b, s, n); // 合并到数组b
        s += s;
        MergePass(b, a, s, n); // 合并到数组a
        s += s;
    }
}

int main(){
    int n;
    cin >> n;
    for(int i = 0; i < n; i++){
        cin >> a[i];
    }
    MergeSort(a, n);
    for(int i = 0; i < n; i++){
        cout << a[i] << endl;
    }
    system("pause");
    return 0;
}

如果想了解归并排序改进版具体解释，欢迎访问老铁博客。 递归与分治