Python快速排序返回原始输入

这是我的快速排序代码

def quicksort(A):
    if len(A) > 1:
        pivot = A[0]
        L = []
        E = []
        R = []
        for i in A:
            if i < pivot:
                L.append(i)
            elif i == pivot:
                E.append(i)
            else:
                R.append(i)
        quicksort(L)
        quicksort(R)
        A = L + E + R

是

---

但是，当我使用调试器逐步处理函数时，A所保存的最后一个值是[2,3,5,6,7]，这是经过排序的，为什么A在函数执行后不保存这个值？

问题是最后一行没有做你认为它做的事情：

A = L + E + R

这将L、E和R一起添加到一个新列表中，并将该新列表绑定到局部变量

a

。它不会以任何方式影响

A

以前绑定到的列表

您可能想做的是替换

A

绑定到的现有列表的内容。像这样：

A[:] = L + E + R

---

你会问“为什么A在函数执行后不保存它？”那么，在函数执行后，

A

根本不存在。这就是局部变量的全部要点

---

当然

数组

存在。和

array

和

A

最初是对同一列表的引用。如果你改变这个列表，你就会得到你想要的。如果你让

A

引用一个不同的列表，你就不需要了。

问题是最后一行没有做你认为它做的事情：

A = L + E + R

这将L、E和R一起添加到一个新列表中，并将该新列表绑定到局部变量

a

。它不会以任何方式影响

A

以前绑定到的列表

您可能想做的是替换

A

绑定到的现有列表的内容。像这样：

A[:] = L + E + R

---

你会问“为什么A在函数执行后不保存它？”那么，在函数执行后，

A

根本不存在。这就是局部变量的全部要点

当然

数组

存在。和

array

和

A

最初是对同一列表的引用。如果你改变这个列表，你就会得到你想要的。如果您使

A

引用不同的列表，则不会引用。

您将构建一个新列表

A=L+E+R

，重新绑定本地名称。原始列表不受影响

您需要返回新的列表对象：

def quicksort(A):
    if len(A) > 1:
        pivot = A[0]
        L = []
        E = []
        R = []
        for i in A:
            if i < pivot:
                L.append(i)
            elif i == pivot:
                E.append(i)
            else:
                R.append(i)
        L = quicksort(L)
        R = quicksort(R)
        return L + E + R
    return A

或者，使用“切片指定”就地更新列表：

def quicksort(A):
    if len(A) > 1:
        pivot = A[0]
        L = []
        E = []
        R = []
        for i in A:
            if i < pivot:
                L.append(i)
            elif i == pivot:
                E.append(i)
            else:
                R.append(i)
        quicksort(L)
        quicksort(R)
        A[:] = L + E + R

您构建了一个新列表，重新绑定本地名称。原始列表不受影响

您需要返回新的列表对象：

def quicksort(A):
    if len(A) > 1:
        pivot = A[0]
        L = []
        E = []
        R = []
        for i in A:
            if i < pivot:
                L.append(i)
            elif i == pivot:
                E.append(i)
            else:
                R.append(i)
        L = quicksort(L)
        R = quicksort(R)
        return L + E + R
    return A

或者，使用“切片指定”就地更新列表：

def quicksort(A):
    if len(A) > 1:
        pivot = A[0]
        L = []
        E = []
        R = []
        for i in A:
            if i < pivot:
                L.append(i)
            elif i == pivot:
                E.append(i)
            else:
                R.append(i)
        quicksort(L)
        quicksort(R)
        A[:] = L + E + R

---

他不需要归还它们；他试图在适当的位置改变值，这是一件完全合理和可行的事情，他只是做得不对。@abarnert:Hrm，我想创建新的

L

和

R

对象是可行的。不仅可行，他几乎做对了。看到我的答案了吗？只需将

A=

更改为

A[：]=

，他的代码就可以正常工作。@abarnert:是的，我假设递归调用需要传递上下限，然后我才看到这些调用被赋予了一个新的列表对象。非常感谢，我最初是用返回值来做的，但由于我家庭作业的特殊原因，当我只是在适当的地方修改列表时，效果会更好；他试图在适当的位置改变值，这是一件完全合理和可行的事情，他只是做得不对。@abarnert:Hrm，我想创建新的

L

和

R

对象是可行的。不仅可行，他几乎做对了。看到我的答案了吗？只需将

A=

更改为

A[：]=

，他的代码就可以正常工作。@abarnert:是的，我假设递归调用需要传递上下限，然后我才看到这些调用被赋予了一个新的列表对象。非常感谢，我最初是用返回值来做的，但由于我的家庭作业的特殊原因，当我只是在适当的位置改变列表时，它工作得更好；在函数中您更改了一个数组，而数组没有更改！A不是数组中的指针；在函数中您更改了一个数组，而数组没有更改！