Python 合并排序算法的计数工作

总之，我想计算使用合并排序算法对数组进行排序的距离。我可以使用合并排序来排列数组，但在计算过程中我很难计算需要多少反转

例如，当输入[9,4,8,3]时，我想得到输出[3,4,8,9]和4个倒数。反演的定义是：如果b在b中，c在c中，我们有b>c，那么就需要反演（b，c物质的顺序）。首先，我将得到两个部分（[4,9]，1）和（[3,8]，1），分别表示一个反转。然后，当它们再次合并时，还有另外两个反转：选择3而不是4，选择8而不是9

我的主要问题可能与算法本身无关。它是关于如何使我的变量之一在函数的函数循环中不断演化。（我在Merge_Sort函数中使用了Merge_Sort函数）

def Merge_Sort（a）：
n=len（a）
如果n==1：
如果不是以vars（）表示的“总版本”：
总修订=0
其他：
总版本+=版本索引
返回a，总版本
其他：
m=数学楼层（n/2）
b，rev_ind_b=合并排序（a[：m]）
如果不是以vars（）表示的“总版本”：
总修订=0
其他：
总版本+=版本索引b
c，rev_ind_c=合并排序（a[m:]
如果不是以vars（）表示的“总版本”：
总修订=0
其他：
总修订+=修订索引c
a_排序，rev_ind=Merge（b，c）
如果不是以vars（）表示的“总版本”：
总修订=0
总版本+=版本索引
其他：
总版本+=版本索引
返回一个排序，总版本
def合并（b、c）：
p=len（b）
q=len（c）
d=[]
反向ind=0
而蓝（b）=0或len（c）=0 :
如果（len（b）*len（c）！=0）：
b0=b[0]
c0=c[0]
如果b0则更简单：


当处于最深的递归级别（
n==1
）时，只需返回0作为交换次数。逻辑是，您应该返回列表在递归级别的交换次数，而不考虑较大的列表可能是什么。因此，当
n==1
时，您的列表有一个值，这显然不需要交换
在其他情况下，只需将递归调用得到的计数相加即可。这样，当返回递归树时，它们将增加

以下是
Merge\u Sort
的调整代码：

def Merge_Sort(a):
    n = len(a)
    if n==1:
        return a, 0 # at deepest recursion always return 0 for the number of swaps
    else:
        m = n//2 # use integer division; you don't need `math.floor`
        b , rev_ind_b = Merge_Sort(a[:m])
        c , rev_ind_c = Merge_Sort(a[m:])
        a_sort , rev_ind = Merge(b,c)
        return a_sort , rev_ind_b + rev_ind_c + rev_ind # add the numbers

谢谢你指出我的失明。我不需要担心我在哪一层。我只需要输出三个源的反转，不管它是哪一层。非常感谢。
def Merge_Sort(a):
    n = len(a)
    if n==1:
        return a, 0 # at deepest recursion always return 0 for the number of swaps
    else:
        m = n//2 # use integer division; you don't need `math.floor`
        b , rev_ind_b = Merge_Sort(a[:m])
        c , rev_ind_c = Merge_Sort(a[m:])
        a_sort , rev_ind = Merge(b,c)
        return a_sort , rev_ind_b + rev_ind_c + rev_ind # add the numbers