归并排序与逆序对

归并排序

归并问题按照分治三步法进行介绍：
划分问题：把序列分成元素个数尽量相等的两半
递归求解：把两半元素分别排序
合并问题：把两个有序表合并成一个
借鉴一个博客的图
图解排序算法(四)之归并排序

分而治之

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

合并相邻有序子序列

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

再借鉴一个博客的代码：
白话经典算法系列之五 归并排序的实现（讲的真好）
首先考虑下如何将将二个有序数列合并。这个非常简单，只要从比较二个数列的第一个数，谁小就先取谁，取了后就在对应数列中删除这个数。然后再进行比较，如果有数列为空，那直接将另一个数列的数据依次取出即可。

//将有序数组a[]和b[]合并到c[]中  
void MemeryArray(int a[], int n, int b[], int m, int c[])  
{  
    int i, j, k;  

    i = j = k = 0;  
    while (i < n && j < m)  
    {  
        if (a[i] < b[j])  
            c[k++] = a[i++];  
        else  
            c[k++] = b[j++];   
    }  

    while (i < n)  
        c[k++] = a[i++];  

    while (j < m)  
        c[k++] = b[j++];  
}  

可以看出合并有序数列的效率是比较高的，可以达到O(n)。

解决了上面的合并有序数列问题，再来看归并排序，其的基本思路就是将数组分成二组A，B，如果这二组组内的数据都是有序的，那么就可以很方便的将这二组数据进行排序。如何让这二组组内数据有序了？

可以将A，B组各自再分成二组。依次类推，当分出来的小组只有一个数据时，可以认为这个小组组内已经达到了有序，然后再合并相邻的二个小组就可以了。这样通过先递归的分解数列，再合并数列就完成了归并排序。

//将有二个有序数列a[first...mid]和a[mid...last]合并。  
void mergearray(int a[], int first, int mid, int last, int temp[])  
{  
    int i = first, j = mid + 1;  
    int m = mid,   n = last;  
    int k = 0;  

    while (i <= m && j <= n)  
    {  
        if (a[i] <= a[j])  
            temp[k++] = a[i++];  
        else  
            temp[k++] = a[j++];  
    }  

    while (i <= m)  
        temp[k++] = a[i++];  

    while (j <= n)  
        temp[k++] = a[j++];  

    for (i = 0; i < k; i++)  
        a[first + i] = temp[i];  
}  
void mergesort(int a[], int first, int last, int temp[])  
{  
    if (first < last)  
    {  
        int mid = (first + last) / 2;  
        mergesort(a, first, mid, temp);    //左边有序  
        mergesort(a, mid + 1, last, temp); //右边有序  
        mergearray(a, first, mid, last, temp); //再将二个有序数列合并  
    }  
}  

bool MergeSort(int a[], int n)  
{  
    int *p = new int[n];  
    if (p == NULL)  
        return false;  
    mergesort(a, 0, n - 1, p);  
    delete[] p;  
    return true;  
}  

看了刘汝佳的算法竞赛入门经典，发现了更简洁的写法。贴出代码和解释：

CODE：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
const int maxn = 1000;
void merge_sort(int* A, int x,int y, int* T)
{
    if(y-x > 1)
    {
        int m = x + (y-x)/2;
        int p = x, q = m, i = x;//p为合并时左边下标，q为右边下标
        merge_sort(A, x, m, T);//左边排序
        merge_sort(A, m, y, T);//右边排序
        while(p < m || q < y){//只要有一个序列非空就要继续合并数组
            if(q >= y || (p < m && A[p] <= A[q]))//如果
                T[i++] = A[p++];//从左边数组复制到临时空间
            else
                T[i++] = A[q++];//从右边数组复制到临时空间
        }
        for(i = x; i < y; i++)
            A[i] = T[i];//从辅助空间复制回A数组
    }
}

int main()
{
    int n;
    int A[maxn], T[maxn];
    cin >> n;
    for(int i = 0; i < n; i++)
        cin >> A[i];
    merge_sort(A,0,n,T);
    for(int i = 0; i < n; i++)
        cout << A[i] << ' ';
    return 0;
}

逆序对

再引用一个很好的博客利用归并排序求逆序对

在归并排序的合并步骤中，假设将两个有序数组A[] 和有序数组B[] 和并为一个有序数组C[]。计算逆序对问题转换为计算逆序对(a,b)的问题，其中a来自A[], b来自B[]。当a < b的时候，不计数，当a>b的时候(a,b)就是逆序对，由于A[]是有序的，那么A[]中位于a之后的元素对于B[]中的元素b也形成了逆序对，于是对于逆序对(a,b)，（假设A[]的起始下标为sa,结束下标为ea,a的下标为pos）实际上合并成C[]后会会产生ea-pos+1个逆序对。

也就是说，合并过程中，每次出现一对这样的(a,b),逆序对数目sum = sum + ea-pos+1 ;
根据这样的原理，再给予对归并排序的理解，将上面的计算公式加入到归并排序中，就可以在O(nlogn)的时间复杂度里计算出一个给定数字序列中逆序对的数目。

再看刘汝佳的描述：
只要对于右边的每个j，统计左边比它大的元素个数f(j)，则所有f(j)之和便是答案。
由于合并操作是从小到大进行的，当右边的A[j]复制到T中时，左边还没来得及复制到T的那些数就是左边所有比A[j]大的数
在归并排序的代码的基础上
将else T[i++] = A[q++];改为else{T[i++] = A[q++];cnt += m-p}。在调用前应给cnt清零。
代码按上面描述改一下就可以了

扫描二维码关注公众号，回复： 2570403 查看本文章

CODE

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
const int maxn = 1000;
int cnt;
void merge_sort(int* A, int x,int y, int* T)
{
    if(y-x > 1)
    {
        int m = x + (y-x)/2;
        int p = x, q = m, i = x;//p为合并时左边下标，q为右边下标
        merge_sort(A, x, m, T);//左边排序
        merge_sort(A, m, y, T);//右边排序
        while(p < m || q < y){//只要有一个序列非空就要继续合并数组
            if(q >= y || (p < m && A[p] <= A[q]))//如果
                T[i++] = A[p++];//从左边数组复制到临时空间
            else
            {
                T[i++] = A[q++];//从右边数组复制到临时空间
                cnt +=m-p;
            }
        }
        for(i = x; i < y; i++)
            A[i] = T[i];//从辅助空间复制回A数组
    }
}

int main()
{
    int n;
    int A[maxn], T[maxn];
    cin >> n;
    for(int i = 0; i < n; i++)
        cin >> A[i];
    cnt = 0;
    merge_sort(A,0,n,T);
    for(int i = 0; i < n; i++)
        cout << A[i] << ' ';
    cout << endl;
    cout << cnt << endl;
    return 0;
}