Python Quicksort实施

Question

I tried to implement the recursive quicksort in Python, but it doesn't work. I know that there is the problem that the array doesn't get sorted because the pivot is always higher than i , which results in the problem that i is always equals to m .

def partition(array):
    pivot = array[-1]
    m = 0

    for i in range(len(array) - 1):
        if array[i] < pivot:
            array[i], array[m] = array[m], array[i]
            m += 1

        else:
            continue

    array[m], array[len(array)-1] = array[len(array)-1], array[m]

    return m

def quicksort(array):
    if len(array) > 1:
        m = partition(array)
        quicksort(array[:m])
        quicksort(array[m+1:])
        return array


def main():
    testarray = [3,6,2,4,5,1,9,8,7,10,14]
    print(quicksort(testarray))

if __name__ == '__main__':
    main()

Answer 1

Two things. Firstly, you forgot to return array when it's of length 1, and secondly you aren't actually modifying array before returning. This will work.

def quicksort(array):
    if len(array) > 1:
        m = partition(array)

        # return the concatenation of the two sorted arrays
        return quicksort(array[:m]) + quicksort(array[m:])

    else:
        return array

Answer 2

For those looking for an iterative/non-recursive version of Quicksort, here's an implementation I came up with in Python:

from random import randint

def default_comparator_fn(a, b):
    return -1 if a < b else (1 if a > b else 0)

def reverse_comparator_fn(a, b):
    return default_comparator_fn(b, a)

def quick_sort(A, comparator_fn=default_comparator_fn):
    n = len(A)
    if n < 2:
        # The list has only 1 element or does not have any.
        return A
    # There are at least 2 elements.
    partitions = [[0, n - 1]] # [[start, end]]
    while len(partitions):
        partition = partitions.pop()
        start = partition[0]
        end = partition[1]
        pivot_index = randint(start, end)
        pivot = A[pivot_index]
        A[pivot_index], A[start] = A[start], A[pivot_index]
        breakpoint_index = start
        k = start + 1
        m = end
        while k <= m:
            res = comparator_fn(A[k], pivot)
            if res < 0:
                breakpoint_index = k
            else:
                while m > k:
                    res = comparator_fn(A[m], pivot)
                    if res < 0:
                        breakpoint_index = k
                        A[m], A[k] = A[k], A[m]
                        m -= 1
                        break
                    m -= 1
            k += 1
        A[start], A[breakpoint_index] = A[breakpoint_index], A[start]
        if start < breakpoint_index - 1:
            partitions.append([start, breakpoint_index - 1])
        if breakpoint_index + 1 < end:
            partitions.append([breakpoint_index + 1, end])
    return A

# Example:
A = [4, 2, 5, 1, 3]
quick_sort(A) # Sort in ascending order ([1, 2, 3, 4, 5]).
quick_sort(A, reverse_comparator_fn) # Sort in descending order ([5, 4, 3, 2, 1]).

This implementation of Quicksort accepts an optional custom comparator function which defaults to a comparator which compares the elements of the list in ascending order.