[leetcode日记]面试题51-数组中的逆序对

在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数。

示例 1:

输入: [7,5,6,4] 输出: 5

限制：

0 <= 数组长度 <= 50000

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/shu-zu-zhong-de-ni-xu-dui-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

乍一看肯定是这种题目怎么可能是困难？哦原来数组长度是50000，也就是说不能是O（n²）的时间复杂度，最多是O（nlgn）。不管怎么说，先试着用暴力轮询试一试：

int reversePairs(int* nums, int numsSize){
    int i,j;
    int count = 0;
    for (i = 0;i<numsSize - 1; i++){
        for (j = i+1; j< numsSize ; j++){
            if (nums[i] > nums[j]){
                count++;
            }
        }
    }
    return count;
}

果然是会超时的……那么再想想有没有什么办法可以统计逆序数的个数？
1.冒泡，统计冒泡的次数；很明显这个也是O（n²）的时间复杂度，直接pass。
2.思路和上述一样，通过排序的手段使得统计出升序数列。那么有什么O（nlgn）的排序办法适合这道题目呢？想到了归并排序。在归并过程中不断统计、累加排序消减掉的逆序对数量，直到整个数列逆序对数量为0。

进一步思考，如何能够更快地实现统计逆序对数量呢？（假定左边和右边都已经从小到大排序）

写个例子试试，如135||246.
肉眼观察，逆序对有3对，3贡献了一对，5贡献了2对。

大概有思路了嘛？用双指针可以解决问题——分别从左右序列的第一位开始，左指针小于右指针则左指针右移，否则右指针右移。如何计算贡献呢？找到右指针所指下一位大于左指针所指的数、但是当前右指针所指的数小于左指针，
说的是不是有点难以明白？可以看下面的例子，具体如下（加粗为指针所指）：

135||246——贡献0
135||246——贡献1（此时计算贡献因为右指针下一位4>3而当前的2<3）
135||246——贡献0
135||246——贡献2（贡献2的原因是4左侧还有一个小于4的数字,此时计算贡献原因同上）
135||246——贡献0

累加可知总贡献为3，也就是所有的逆序对数。

再举个例子：346||125
肉眼观察逆序对为7，实现如下：
346||125——（先不计算贡献，因为右指针下一位2仍然小于3）
346||125——贡献为2
346||125——贡献为2
346||125——先不计算贡献，右侧下一位5<6
346||125——贡献为3
总共贡献就是2+2+3=7啦！

讲清楚了吗？想清楚了吗？
代码实现如下：

//【算法思路】归并排序。典型的使用归并排序解决逆序对。
// 对原数组进行归并排序，再排序过程中，找到逆序对并记录结果
// 注意：归并时的分组方法，以n/2为分界点，n/2属于右侧
int reversePairs(int* nums, int numsSize){
    if(numsSize <= 1) {
        return 0;
    }

    int num = 0;
    int mid = numsSize / 2;

    num += reversePairs(nums, mid);
    num += reversePairs(&nums[mid], numsSize - mid);

    int *tmp = (int *)calloc(numsSize, sizeof(int));
    int tid = 0;

    //3while结构，开始归并
    int lid = 0;
    int rid = mid;

    while(lid < mid && rid < numsSize) {
        if(nums[lid] > nums[rid]) {
            //注意计算增加的个数，左侧有mid - lid个
            num += mid - lid;
            tmp[tid++] = nums[rid++];
        } else {
            tmp[tid++] = nums[lid++];
        }
    }

    //处理剩余左边
    while(lid < mid) {
        tmp[tid++] = nums[lid++];
    }

    //处理剩余右边
    while(rid < numsSize) {
        tmp[tid++] = nums[rid++];
    }

    //将结果转存
    for(int i = 0; i < numsSize; i++) {
        nums[i] = tmp[i];
    }
    free(tmp);

    return num;
}

结果如下：

虽然空间已经还行了，但是时间还是比较拉跨的……还能不能继续优化呢？容我三思……
1.首先是每次函数迭代都要申请空间，是否可以一次直接申请完所有需要空间？

• 可以！这样的话操作就必须要以指针的形式传递左指针和右指针，并且每次都需要传递指针参数进函数！指针操作也带来了一个好处，可以调用系统函数memcpy来进行参数的复制保存。

重写了一下代码，几乎是全新的答案了：

int merge_sort_return_reverse_cnt(int *nums, int *tmp, int nums_size)
{
    int *left = NULL;
    int *right = NULL;
    int cnt = 0;
    int reverse_cnt = 0;

    if (nums_size == 0 || nums_size == 1) {
        return 0;
    }

    reverse_cnt += merge_sort_return_reverse_cnt(nums, tmp, nums_size / 2);
    reverse_cnt += merge_sort_return_reverse_cnt(nums + nums_size / 2, tmp, nums_size - nums_size / 2);

    left = nums;
    right = nums + nums_size / 2;

    while(left < nums + nums_size / 2 && 
        right < nums + nums_size) {
        if (*left > *right) { //从大到小排序
            reverse_cnt += nums + nums_size - right; //左边比右边大的元素数目等于右侧剩余的元素数目
            tmp[cnt++] = *left++;
        } else {
            tmp[cnt++] = *right++;
        }
    }

    while (left < nums + nums_size / 2) {
        tmp[cnt++] = *left++;
    }

    while (right < nums + nums_size) {
        tmp[cnt++] = *right++;
    }

    memcpy(nums, tmp, nums_size * sizeof(int));

    return reverse_cnt;
}

int reversePairs(int* nums, int numsSize)
{
    int ret;
    int *tmp = NULL;

    tmp = (int *)malloc(numsSize * sizeof(int));
    if (tmp == NULL) {
        return 0;
    }

    ret = merge_sort_return_reverse_cnt(nums, tmp, numsSize);

    free(tmp);

    return ret;
}

/*
int main( ){
	int nums[6] ={5,4,3,21,1,7} ;
	printf("%d",reversePairs(nums,6));   //ans = 8; 

	return 0;
}
*/

运行时间和空间都大大减少了，性能还不错！

看在我那么努力的份上，点个赞再走呗~