Question

我试图在Python中实现递归quicksort，但是它不起作用。我知道存在一个问题，即数组未排序，因为枢轴始终高于i，这导致了i始终等于m的问题。 / p>

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

两件事。首先，您忘记了长度为1的array的返回，其次您实际上并没有在返回之前修改array。这将起作用。

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

对于那些正在寻找Quicksort的迭代/非递归版本的人来说，这是我在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]).

此Quicksort的实现接受一个可选的自定义比较器功能，该功能默认为一个比较器，该比较器按升序比较列表中的元素。

Python Quicksort实施

2 个答案: