在python中合并排序代码-递归函数调用

Question

我正在尝试理解以下用于合并排序的 python 代码。

函数mergeSort 没有返回任何值，我们也没有将排序列表存储到lefthalf 变量中。那么变量lefthalf 的值是如何在函数被调用后更改为 { 例如为 [26,54] } 的。

def mergeSort(alist):
    print("Splitting ",alist)
    if len(alist)>1:
        mid = len(alist)//2
        lefthalf = alist[:mid]
        righthalf = alist[mid:]

        print("Before left call------>",lefthalf)
        mergeSort(lefthalf)
        print("after left call------>",lefthalf)
        mergeSort(righthalf)

        i=0
        j=0
        k=0
        while i < len(lefthalf) and j < len(righthalf):
            if lefthalf[i] < righthalf[j]:
                alist[k]=lefthalf[i]
                i=i+1
            else:
                alist[k]=righthalf[j]
                j=j+1
            k=k+1

        while i < len(lefthalf):
            alist[k]=lefthalf[i]
            i=i+1
            k=k+1

        while j < len(righthalf):
            alist[k]=righthalf[j]
            j=j+1
            k=k+1
    print("Merging ",alist)

alist = [54,26,93,17,77,31,44,55,20]
mergeSort(alist)
print(alist)

输出：

Splitting  [54, 26, 93, 17, 77, 31, 44, 55, 20]
Before left call------> [54, 26, 93, 17]
Splitting  [54, 26, 93, 17]
Before left call------> [54, 26]
Splitting  [54, 26]
Before left call------> [54]
Splitting  [54]
Merging  [54]
after left call------> [54]
Splitting  [26]
Merging  [26]
Merging  [26, 54]
after left call------> [26, 54]
Splitting  [93, 17]
Before left call------> [93]
Splitting  [93]
Merging  [93]
after left call------> [93]
Splitting  [17]
Merging  [17]
Merging  [17, 93]

... ... 依此类推，直到它成为一个排序列表。

提前谢谢你。

Answer 1

首先，在lefthalf = alist[:mid] 和righthalf = alist[mid:] 中。它创建了两个新列表：lefthalf 和 rightlhalf，它们是 alist 中左半边整数和右半边整数的副本。当您更新这些列表时，alist 不会改变。您可以使用以下代码对其进行测试：

>>> x = [1, 2, 3, 4]
>>> a = x[:2]
>>> a
[1, 2]
>>> b = x[2:]
>>> b
[3, 4]
>>> a[1] = 10
>>> a
[1, 10]
>>> b
[3, 4]
>>> x
[1, 2, 3, 4]

其次，在合并过程中，alist 值会原地变异。例如。当 alist 为 [54, 26]，lefthalf 为 [54]，righthalf 为 [26] 时，merge 会将 alist 更新为 [26, 54]。这就是为什么在调用mergeSort(lefthalf) 时将lefthalf 更改为[26, 54]。

最后，当它调用megeSort(lefthalf) 和mergeSort(righthalf) 时，由于引用传递，它实际上更新了lefthalf 和righthalft。这个可以用代码测试一下：

>>> l = [1, 2, 3]
>>> def update(x):
...     x[0] = 100
...
>>> update(l)
>>> l
[100, 2, 3]

所以总而言之，整个过程是针对给定的 alist，它创建了两个新的列表：lefthalf 和 righthalf。并且在对lefthalf和righthalf进行排序之后，通过合并lefthalf和righthalf来更新alist。递归执行此过程将对 alist 进行排序。

如果现在清楚了，请告诉我。

Answer 2

数组内容在函数末尾写回alist，alistlefthalf在上一层。

当我从 C 切换到 Python 时，我发现这真的很令人困惑，但是在 Python 中，一切都是对对象的引用，因此所有函数调用实际上都是 pass-by-reference。