使用快速排序对列表进行排序时出现“超出最大递归深度”错误

Question

我试图用快速排序算法对一个几乎排序的 100,000 个数字列表进行排序，但我收到了这个错误：

Traceback (most recent call last):
  File "/Users/MacbookPro/Documents/Faculta/alg sortare pyth/quicksort.py", line 48, in <module>
    quickSort(alist)
  File "/Users/MacbookPro/Documents/Faculta/alg sortare pyth/quicksort.py", line 5, in quickSort
    quickSortHelper(alist,0,len(alist)-1)
  File "/Users/MacbookPro/Documents/Faculta/alg sortare pyth/quicksort.py", line 12, in quickSortHelper
    quickSortHelper(alist,first,splitpoint-1)
  File "/Users/MacbookPro/Documents/Faculta/alg sortare pyth/quicksort.py", line 12, in quickSortHelper
    quickSortHelper(alist,first,splitpoint-1)
.
.
(a bunch of the last line)
.
.
  File "/Users/MacbookPro/Documents/Faculta/alg sortare pyth/quicksort.py", line 10, in quickSortHelper
    splitpoint = partition(alist,first,last)
  File "/Users/MacbookPro/Documents/Faculta/alg sortare pyth/quicksort.py", line 25, in partition
    while leftmark <= rightmark and alist[leftmark] <= pivotvalue:
RuntimeError: maximum recursion depth exceeded in cmp

这是我的代码：

from timeit import default_timer as timer
import resource

start = timer()

def quickSort(alist):
   quickSortHelper(alist,0,len(alist)-1)

def quickSortHelper(alist,first,last):
   if first<last:    
       splitpoint = partition(alist,first,last)    
       quickSortHelper(alist,first,splitpoint-1)
       quickSortHelper(alist,splitpoint+1,last)


def partition(alist,first,last):
   pivotvalue = alist[first]    
   leftmark = first+1
   rightmark = last    
   done = False
   while not done:    
       while leftmark <= rightmark and alist[leftmark] <= pivotvalue:
           leftmark = leftmark + 1    
       while alist[rightmark] >= pivotvalue and rightmark >= leftmark:
           rightmark = rightmark -1    
       if rightmark < leftmark:
           done = True
       else:
           temp = alist[leftmark]
           alist[leftmark] = alist[rightmark]
           alist[rightmark] = temp    
   temp = alist[first]
   alist[first] = alist[rightmark]
   alist[rightmark] = temp   
   return rightmark

with open('lista.txt', 'r') as f:
    long_string = f.readline()
    alist = long_string.split(',')
quickSort(alist)
f = open("quick.txt", "w")
print >>f,(alist)
print resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1000
end = timer()
print(end - start)
f.close()
print 'Quick\n'

我之前尝试过对同一个列表进行排序，在先随机洗牌之后，然后它起作用了。

Answer 1

当输入已经排序时，您选择的枢轴元素（范围中的最左侧）将给出“错误”拆分。 “坏”的意思是 partition 将返回一个等于 first 的值的 rightmark。

这意味着在 quickSortHelper 中，一个 n 值的列表将被拆分为一个包含零元素的列表（第一次递归调用）和一个 n 的列表-1 值（第二次递归调用）。如果输入已经排序，则此模式将在每个递归级别上不断重复。因此，如果您的输入大小为 1000，那么您将拥有 1000 的递归深度。Python 会维护一个最大递归深度，在该深度时它将触发异常。对于大型排序列表，您将遇到此限制。

附带说明，在这种情况下，您的最坏情况运行时间也为 O(n²)。

如何解决？

您可以将 Python 配置为 allow deeper recursion，使用 sys.setrecursionlimit。但这并不可取，因为这意味着您仍然会使用大量堆栈内存，并且不要摆脱排序输入的最坏情况运行时间。

解决此问题的更好方法是随机选择您的枢轴元素，在索引 first 和 last 之间的某个位置，然后将该索引处的值与最左边的值交换（或最右边，但在您的实现中它会被留下）。这会将超出最大递归深度错误的概率降低到几乎为零。

另请参阅Wikipedia 如何指代您遇到的问题（我用粗体强调）：

支点的选择

在快速排序的早期版本中，分区的最左侧元素通常会被选为枢轴元素。不幸的是，这会导致已经排序的数组出现最坏情况，这是一个相当常见的用例。 通过为枢轴选择随机索引、选择分区的中间索引或（特别是对于较长的分区）选择第一个的中位数，这个问题很容易解决，枢轴分区的中间和最后一个元素（由 Sedgewick 推荐）。

要实现随机选择的枢轴索引，请将这两行添加到 partition 函数的最顶部：

pivotmark = random.randint(first,last)
alist[first], alist[pivotmark] = alist[pivotmark], alist[first]

当然，你需要import random。

这将解决您遇到的问题。如果您想进一步提高性能，您可以查看现有的其他几种解决方案，例如上面引用的 Wikipedia 文章中提到的解决方案，并了解它们在您处理的输入上的表现。

注意：另请参阅如何在一行中交换元素...