计算数组中的逆序对

描述

在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P mod 1000000007

数据范围：  对于 50\%50% 的数据, size\leq 10^4size≤104
对于 100\%100% 的数据, size\leq 10^5size≤105

数组中所有数字的值满足 0 \le val \le 10000000≤val≤1000000

要求：空间复杂度 O(n)O(n)，时间复杂度 O(nlogn)O(nlogn)

输入描述：

题目保证输入的数组中没有的相同的数字

• 思路：采用归并排序算法

class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None


class Solution:
    def InversePairs(self, data: List[int]) -> int:
        _, res = self.merge_sort(0, len(data) - 1, data)
        print(len(_), _)
        return res % 1000000007

    def merge_sort(self, start, end, data):
        if start > end:
            return [], 0
        if start == end:
            return [data[start]], 0

        mid = (start + end) >> 1
        left_d, l_c = self.merge_sort(start, mid, data)
        right_d, r_c = self.merge_sort(mid + 1, end, data)
        c = l_c + r_c
        res = []
        l_idx = r_idx = 0
        while True:
            if l_idx >= len(left_d):
                res.extend(right_d[r_idx:])
                break
            if r_idx >= len(right_d):
                res.extend(left_d[l_idx:])
                break

            if left_d[l_idx] <= right_d[r_idx]:
                res.append(left_d[l_idx])
                l_idx += 1
            else:
                res.append(right_d[r_idx])
                c += len(left_d) - l_idx
                r_idx += 1
        return res, c

def list_to_list_node(l):
    head = ListNode(None)
    temp = head
    for i in l:
        temp.next = ListNode(i)
        temp = temp.next
    return head.next

def list_node_to_list(head):
    temp = head
    res = []
    while temp:
        res.append(temp.val)
        temp = temp.next
    return res

if __name__ == '__main__':
    a = [1,2,3,4,5,6,7,0,9]
    print(len(a))
    print(Solution().InversePairs(a))