归并排序之逆序对

归并排序是基于分治法的思想，将待排序的数组划分至只有一个元素，一个元素肯定是有序的，然后对数组两两进行合并，直到合并成一个数组。在将两个数组合并为一个数组的过程中，需要使用临时的存储空间。将两个数组合并好了之后，再将临时空间中的数据拷贝到原数组中，这样原数组中的元素就部分有序了。

void merge(int *a, int start, int mid, int end, int *tmp)
{
    int i = start, j = mid + 1;
    int k = 0;

    while(i <= mid && j <= end)
    {
        if(a[i] <= a[j])
            tmp[k++] = a[i++];
        else
            tmp[k++] = a[j++];
    }
    while(i <= mid)
    {
        tmp[k++] = a[i++];
    }   
    while(j <= end)
    {   
        tmp[k++] = a[j++];
    }   

    //将存储好的数据又放回到a中
    for(i = 0; i < k; i++)
        a[start + i] = tmp[i];
}
void mergesort(int *a, int start, int end, int *tmp)
{
    if(start < end)
    {   
        int mid = (start + end) / 2;

        mergesort(a, start, mid, tmp);
        mergesort(a, mid + 1, end, tmp);
        merge(a, start, mid, end, tmp);
    }
}

bool MergeSort(int *a, int n)
{
    if(NULL == a || n <= 0)
        return false;

    int *tmp = new int[n];

    mergesort(a, 0, n - 1, tmp);

    delete []tmp;

    return true;
}

在数组中的两个数字如果前面一个大于后面的数字，则这对数字组成一个逆序对。先给定一个数组，求该数组中逆序对的个数。

显然最简单的方法是使用两层循环，对某一个数字，将其与其后的每个数字比较，时间复杂度为O(n*n)。

其实这个问题可以使用分治法来解决：假设该数组被划分为了两部分：a[start,...,mid]、b[mid+1,...,end]，其中a、b都已经有序，并且求得了a、b中逆序对的个数，现在就需要将a中的元素与b中的元素比较，求得新的逆序对。开始时，p1指向a中的最后一个元素，p2指向b中的最后一个元素。如果p1所指向的元素大于p2所指向的元素，则p1所指的元素与p2所指的及其之前的元素都是逆序对，再把p1所指向的元素拷贝到临时空间中，p1指向前面一个元素继续处理。如果p1所指向的元素小于等于p2所指向的元素，则只将p2所指向的拷贝到临时空间中，然后指向前一个元素，继续处理。很明显，上述方法就是利用了归并排序思想，我们只需要修改合并算法。

int MergeInversePairs(int *a, int start, int mid, int end, int *tmp)
{
    int i = mid, j = end;
    int k = end - start;
    int count = 0;

    while(i >= start && j >= (mid + 1))
    {
        if(a[i] > a[j])
        {
            count += (j - mid);
            tmp[k--] = a[i--];
        }
        else
        {
            tmp[k--] = a[j--];
        }
    }
    while(i >= start)
    {
        tmp[k--] = a[i--];
    }
    while(j >= mid + 1)
    {
        tmp[k--] = a[j--];
    }

    for(i = 0; i <= end - start; i++)
        a[start + i] = tmp[i];

    return count;
}
int InversePairsCore(int *a, int start, int end, int *tmp)
{
    if(start == end)
        return 0;

    int mid = (start + end) / 2;
    int left = InversePairsCore(a, start, mid, tmp);
    int right = InversePairsCore(a, mid + 1, end, tmp);
    int count = MergeInversePairs(a, start, mid, end, tmp);
    return left + right + count;
}
int InversePairs(int *a, int length)
{
    if(NULL == a || length <= 0)
        return -1;

    int *tmp = new int[length];
    int count = InversePairsCore(a, 0, length - 1, tmp);

    delete []tmp;

    return count;
}