在归并排序算法的基础上改写代码，实现逆序对计数问题的算法java实现和Python实现

在归并排序算法的基础上改写代码，实现逆序对计数问题的算法，并测试其正确性，只需要输出逆序对的数量即可

public class MergeSort {
    public static void main(String[] args) {
        int[]  X ={10,9,8,7,6,5,4,3,2,1};
        MergeSort M = new MergeSort();
        System.out.println(M.countSum(X));
    }
    public int countSum(int[] X) {
        int len = X.length;
        if (len < 2) {
            return 0;
        }
        //拷贝数组
        int[] copy = new int[len];
        for (int i = 0; i < len; i++) {
            copy[i] = X[i];
        }

        int[] temp = new int[len];
        return mergeSort(copy, 0, len - 1, temp);
    }
    //X[left...right]计算逆序对个数并排序
    private int mergeSort(int[] X, int left, int right, int[] temp) {
        //递归终止
        if (left == right)
            return 0;
        //下面与上次不同，进行代码改进
        //本来是（left+right）/2，为了防止整型溢出
        int mid = left + (right - left) / 2;
        int sum1 = mergeSort(X, left, mid, temp);
        int sum2 = mergeSort(X, mid + 1, right, temp);
        //优化
        //监测到数组是有序的，不需要进行sum3
        if (X[mid] <= X[mid + 1])
            return sum1 + sum2;
        int sum3 = mergeAndCount(X, left, mid, right, temp);
        return sum1 + sum2 + sum3;
    }
    private int mergeAndCount(int[] X, int left, int mid, int right, int[] temp) {
        //改进，这次全局只用了一个辅助数组进行合并计算
        //如果每一次调用都创建一个辅助数组，会产生较大的空间开销，以后创建和销毁，会对资源的浪费
        for (int i = left; i <= right; i++)
            temp[i] = X[i];
        int i = left;
        int j = mid + 1;
        int count = 0;
        for (int k = left; k <= right; k++) {
            if (i == mid + 1) {//判断是否超出范围
                X[k] = temp[j];
                j++;
            } else if (j == right + 1) {//判断是否超出范围
                X[k] = temp[i];
                i++;
            } else if (temp[i] <= temp[j]) {
                X[k] = temp[i];
                i++;
            } else {
                X[k] = temp[j];
                j++;
                //全部代码就只有这里进行计算逆序对
                count += (mid - i + 1);
            }
        }
        return count;
    }
}

def InversionNum(lst):
    # 改写归并排序,在归并排序中，每当R部分元素先于L部分元素插入原列表时，逆序对数要加L剩余元素数
    if len(lst) == 1:
        return lst,0
    else:
        n = len(lst) // 2
        lst1,count1 = InversionNum(lst[0:n])
        lst2,count2 = InversionNum(lst[n:len(lst)])
        lst,count = Count(lst1,lst2,0)
        return lst,count1+count2+count

def Count(lst1, lst2,count): 
    i = 0
    j = 0
    res = []
    while i < len(lst1) and j < len(lst2):
        if lst1[i] <= lst2[j]:
            res.append(lst1[i])
            i += 1
        else:
            res.append(lst2[j])
            count += len(lst1)-i 
            # 当右半部分的元素先于左半部分元素进入有序列表时，逆序对数量增加左半部分剩余的元素数
            j += 1
    res += lst1[i:]
    res += lst2[j:]
    return res,count


print(InversionNum([10,9,8,7,6,5,4,3,2,1]))  
# 输出为：[1,2,3,4,5,6,7,8,9,10] 45