Quicksort超过最大递归深度

Question

I've implemented a quicksort algorithm to practice Python, here's my code:

def sort(array):   
    if len(array) > 1:
        pivot = array[0]
        left = []
        right = []
        equal = []
        for x in array:
            if x < pivot:
                left.append(x)
            elif x == pivot:
                equal.append(x)
            else:
                right.append(x)
        return sort(left)+equal+sort(right)
    return array

Now, the algorithm is working fine, but if I remove the equal list and do my loop like this:

    for x in array:
        if x < pivot:
            left.append(x)
        else:
            right.append(x)
    return sort(left) + sort(right)

I get the maximum recursion depth error when I try to sort the right list. It's not because that list also contains the equal elements, I tested it with very small lists. I'm feeling that this will be some really stupid mistake on my part, but I've had no luck in finding it so far.

Answer 1

It may look like you don't need the equal list, but its presence is critical. By putting the elements that go there into the right list, you force the algorithm to keep sort() ing elements that are already sorted. That's why your recursion limit is exceeded.

By adding a print "sorting", array at the start of your function, you can see what happens:

>>> sort([3,1,2])
('sorting ', [3, 1, 2])
('sorting ', [1, 2])
('sorting ', [])
('sorting ', [1, 2])
('sorting ', [])
('sorting ', [1, 2])
('sorting ', [])
... etc. until crash

Answer 2

The pivot always goes into right as the zeroth element, and gets chosen again when you recurse on right . Since right also contains everything that is equal to or bigger than that, the next call will put all of the current elements into the new right .

It will only ever reduce to one element if the pivot is the unique largest item in the list - which ultimately means that in any other case than your list having no duplicates and already being sorted in descending order, you will recurse indefinitely.

You don't need to have an equal list , but you do need to take at least the chosen pivot out of the recursion, so the next call down choses a different one. So choose it this way:

pivot = array.pop(0)

and adjust your reconstruction of the sorted list:

return sort(left) + [pivot] + sort(right)