Question

我最近了解到人们如何努力使quicksort更快。从随机选择一个pivot元素到为较小的数组切换到Insertion排序，甚至用三向分区处理相等的键。我对随机生成的数据如何工作以及分析一些python代码的想法感到好奇。我附上下面的脚本。问题是脚本最终需要花费相同的时间！当我使用％prun时，看起来quicksort被调用的次数也非常相似。那么，我们所做的所有改进只有在我们的数据满足最坏情况时才会有用（非常多的方向排序错误？）

def hoare_partition(a, lo, hi):

    if lo >= hi or (lo + 1) == len(a) - 1:
        return None
    pivot = a[lo]
    left = lo + 1
    right = hi


    while left <= right and right < len(a):
        while left < len(a) and a[left] < pivot:
            left += 1
        while a[right] > pivot:
            right -= 1
        if left <= right and right < len(a):
            a[left], a[right] = a[right], a[left]
            left += 1
            right -= 1
    a[lo], a[right] = a[right], a[lo]
    return right

def hoare_quicksort(a, lo, hi):
    ''' this is a vanilla implementation of quick sort. this will call the partition method that uses first element as pivot '''

    if lo < hi:
        p = hoare_partition(a, lo, hi)
        if p:
            #print 'calling for ', lo, p - 1
            hoare_quicksort(a, lo, p - 1)  

            #print 'calling for ', p + 1, hi
            hoare_quicksort(a, p + 1, hi)

这是vanilla实现，我们选择第一个元素本身作为pivot。然后，我改为选择中点。

所以，一行变了

mid = lo + (hi - lo)//2

a[lo], a[mid] = a[mid], a[lo]
pivot = a[lo]

然后我也会进行随机数据透视选择，如下所示：

pos = random.randint(lo, hi + 1)


a[lo], a[pos] = a[pos], a[lo]
pivot = a[lo]

现在，我用

打电话给他们

%prun hoare_quicksort([random.randint(0, 10000) for i in xrange(1000)], 0, 999)
%prun mid_quicksort([random.randint(0, 10000) for i in xrange(1000)], 0, 999)
%prun random_quicksort([random.randint(0, 10000) for i in xrange(1000)], 0, 999)

所有这些花费的时间几乎相同（5.22,5.27,5.61毫秒）。当我使用％prun调用它们并查看quicksort被调用的次数时，我再次得到非常相似的数字。那么，那有什么不对？

Answer 1

你的基准破坏了。

您正在对random.randint的1000次迭代进行基准测试，而不是您的种类。
您只运行一次，因此您正在对操作系统中的线程和进程切换延迟进行基准测试。

尝试预先创建源数组并运行每个类别，甚至数百万次。

Answer 2

因此，我们所做的所有改进仅在我们的数据满足时才有用最坏的情况（在错误的方向排序很多？）

它不一定是最差的情况，但数据中任何类型的预先存在的顺序都会给运行时带来麻烦。预先存在的订单是非常常见的，我们想要一种利用它来运行得更快的排序，而不是那种看它和barf的排序。

您已经对随机数据进行了快速搜索测试。对于快速排序而言，这几乎是最好的情况。如果数据来自dict的键，并且使用的哈希导致它们以大部分排序的顺序出现怎么办？

>>> data = dict.fromkeys(random.sample(xrange(10000), 9000)).keys()
>>> timeit.timeit('rand_quicksort(data[:], 0, len(data)-1)', 'from __main__ impo
rt rand_quicksort, data', number=1)
0.06688880239187256
>>> timeit.timeit('hoare_quicksort(data[:], 0, len(data)-1)', 'from __main__ imp
ort hoare_quicksort, data', number=1)
  # about 1000 lines omitted
  File "<stdin>", line 9, in hoare_quicksort
  File "<stdin>", line 9, in hoare_quicksort
  File "<stdin>", line 9, in hoare_quicksort
  File "<stdin>", line 9, in hoare_quicksort
  File "<stdin>", line 9, in hoare_quicksort
  File "<stdin>", line 9, in hoare_quicksort
  File "<stdin>", line 9, in hoare_quicksort
  File "<stdin>", line 9, in hoare_quicksort
  File "<stdin>", line 9, in hoare_quicksort
  File "<stdin>", line 4, in hoare_quicksort
RuntimeError: maximum recursion depth exceeded

好吧，我们得到了一个堆栈溢出，这太糟糕了。即使我们没有，它也会永远变得怪异。

（如果您想重现此结果，请注意您的代码中有一些错误。if p应为if p is not None，random.randint(lo, hi + 1)应为random.randint(lo, hi)或random.randrange(lo, hi + 1)。我必须修复这些以获得正确的测试结果。）

Answer 3

randomize pivot selection不会使quicksort变得更快：它只是为了避免我们的算法执行最坏的情况。假设我们对已经排序的向量进行排序，并且我们决定选择pivot作为每个子数组的rightemost元素：这包含该子数组的最大值，因此quicksort以最不平衡的方式将子数组拆分为2部分。这可以通过随机化来预防。如果我们确定避免最坏情况，我们可以说算法需要相似的时间，直到每个递归级别产生近似恒定平衡的分区，因此我们可以证明递归树深度是恒定的

Quicksort没有变得更快

3 个答案: