Question

这是我的快速排序代码，它选择最合适的值作为支点：

def qsort_right(self, array):
    less = []
    equal = []
    greater = []
    last_value = len(array) - 1

    if len(array) > 1:
        pivot = array[last_value]
        for i in array:
            if i < pivot:
               less.append(i)
            if i == pivot:
               equal.append(i)
            if i > pivot:
                greater.append(i)
        return self.qsort_right(less)+equal+self.qsort_right(greater)
    else:
        return array

我有三个我想要排序的数组。所有3个都是10,000。第一个是随机的，第二个按20％排序，第三个按40％排序。排序适用于前两个，但对于第三个，我得到错误：

maximum recursion depth exceeded

有人可以向我解释为什么会这样吗？我认为，因为所有三个阵列的大小是相同的，如果一个工作，那么它们都可以工作。

以下是我用于创建快速排序无法处理的40％排序数组的代码：

class forty_array():
def __init__(self, size):
    self.forty_array = []
    self.ordered = []
    self.size = size
    self.ordered_keys()

def ordered_keys(self):
    i = 0
    value = 10
    while i < 4000: #for the 20% sorted array, this number is 2000
        value = value + random.randint(0, 450)
        self.ordered.append(value)
        i = i+1

def fill_array(self):
    i = self.size

    while i > 0:
        self.forty_array.append(random.randint(0, 100))
        i = i-1

    j = 0
    k = 0

    while j < 4000: #for the 20% sorted array, this number is 2000
        self.forty_array[k] = self.ordered[j]
        k = k + random.randint(0, 2) #for the 20% sorted array, this number is 5, not 2
        j = j+1

def retreive_array(self):
    self.fill_array()
    return self.forty_array

Answer 1

如果你总是选择最合适的数组值，那么对于已经排序的数组，你有一个O（N ^ 2）最坏的情况，每次递归只会将问题大小减少1。所以在某种程度上＆＃34;排序＆＃34;你将达到python递归深度限制。

枢轴的选择对于避免现实世界数据的快速排序最坏情况非常重要。常见的是选择第一个最后一个和中间元素的中位数，但有许多变化。请记住，无论（常量时间）枢轴选择如何，您始终可以构建一个触发快速排序最坏情况的数据集。这可能会导致您的应用程序中出现拒绝服务攻击。

为了完全避免最坏的情况，你需要使用不同的算法，introsort，heapsort或merge sort是更好的最坏情况排序算法的例子。

快速排序选择正确的中位数递归最大值

1 个答案: