数据结构-从归并排序到数组的逆序对数（微软面试题）

归并排序

1. 归并排序
   与快速排序算法一样，归并排序也是基于分治法的。
   就是将待排序的序列分成两个长度相同的序列，然后再对两个子序列拆分，一直到只剩下一个元素的子序列，为每个子序列排序，然后再将它们合并成一个有序序列。合并两个子序列的过程称为二路归并。
   下面我们来看看原理图（逆序）：

下面是实现代码：

#include<assert.h>
using namespace std;
//仿函数
template<class T>
struct Less
     //逆序仿函数
{

    bool operator()(const T& s, const T& l)
    {
        return s < l;
    }
};
template<class T>
struct Greater
                   // 升序仿函数
{
    bool operator()(const T& s, const T& l)
    {
        return s > l;
    }
};
//归并排序
template<class T=int,class Compare=Greater<T>>
void MergeSort(T* arr,T* tmp,size_t begin,size_t end) //end为可访问的最大下标
{
    assert(arr);
    assert(tmp);
    Compare com;
    if (begin == end)
        return;
    size_t mid = begin + ((end - begin) >> 1);
//这相当于(begin+end)/2，但这样写防止了可能溢出
    size_t left1 = begin;
    size_t right1 = mid;
    size_t left2 = mid + 1;
    size_t right2 = end;
    //递归
    MergeSort<T,Compare>(arr, tmp, left1, right1);
    MergeSort<T,Compare>(arr, tmp, left2, right2);
    int index = begin;
    //合并子序列
    while (left1<=right1&&left2<=right2)
    {
        if (com(arr[left2],arr[left1]))
        {
            tmp[index++] = arr[left1++];
        }
        else
        {
            tmp[index++] = arr[left2++];

        }
    }
        //合并完如左边子序列有剩余
    while (left1 <= right1)
    {
        tmp[index++] = arr[left1++];
    }
        //右边有剩余
    while (left2 <= right2)
    {
        tmp[index++] = arr[left2++];
    }
        //反馈传来的数组中
    for (size_t i = 0; i <= end; ++i)
    {
        arr[i] = tmp[i];
    }
}   
template<class T,class Compare=Greater<T>>
void merge(T* arr, size_t size)
{
    T* _arr = new T[size];
    MergeSort<T,Compare>(arr, _arr, 0, size-1);
}
void MergeTest()
{
    int arr[] = { 1,7,2,9````
6,4,5,3 };
    merge<int>(arr, sizeof(arr) / sizeof(arr[0]));
}

归并排序是稳定的排序.即相等的元素的顺序不会改变.如输入记录 1(1) 3(2) 2(3) 2(4) 5(5) (括号中是记录的关键字)时输出的 1(1) 2(3) 2(4) 3(2) 5(5) 中的2 和 2 是按输入的顺序.这对要排序数据包含多个信息而要按其中的某一个信息排序,要求其它信息尽量按输入的顺序排列时很重要.这也是它比快速排序优势的地方.
2. 求逆序对数（微软面试题2010）
微软2010年笔试题
在一个排列中，如果一对数的前后位置与大小顺序相反，即前面的数大于后面的数，那么它们就称为一个逆序数对。一个排列中逆序的总数就称为这个排列的逆序数。如{ 2，4，3，1 }中，2和1，4和3，4和1，3和1是逆序数对，因此整个数组的逆序数对个数为4，现在给定一数组，要求统计出该数组的逆序数对个数。

这里就是用的归并排序的思想，加上一点小小的改动（相当于假设，左边序列第一个元素大于右边序列第一个元素，那么相当于这个数和右边序列都是逆序，所以逆序个数就是右边序列长度）

int s=0;
template<class T = int>
void MergeSort(T* arr, T* tmp, size_t begin, size_t end)//end为可访问的最大下标
{
    assert(arr);
    assert(tmp);
    if (begin == end)
        return;
    int mid = begin + ((end - begin) >> 1);
    int left1 = begin;
    int right1 = mid;
    int left2 = mid + 1;
    int right2 = end;
    MergeSort(arr, tmp, left1, right1);
    MergeSort(arr, tmp, left2, right2);
    int index = begin;
    while (left1 <= right1&&left2 <= right2)
    {
        if (arr[left1] > arr[left2])
        {
            tmp[index++] = arr[left1++];
            s += right2 - left2 + 1;
        }
        else
        {
            tmp[index++] = arr[left2++];
        }
    }
    while (left1 <= right1)
    {
        tmp[index++] = arr[left1++];
    }
    while (left2 <= right2)
    {
        tmp[ind[] = { 1, 7, 2, 9, 6, 4, 5, 3 };
    merge<int>(arr, sizeof(arr) / si`
eof(arr[0]));
    printf("%d", s);
}

答案是14；