基于栈的10亿数字快速排序

1. 参考点对换操作

def PartSort(array, left, right):
    '''
    left到right的错位替换
    :param array:
    :param left:
    :param right:
    :return:相遇点
    '''
    kid = right
    key = array[kid]#参考比对点,left<right时，left>key的和right<key的元素对换
    while left < right:
        #左边会停留在一个大于key值的元素位置
        while left < right and array[left] <= key:
            left += 1
        #右边会停留在小于key或者right等于left的位置
        while left < right and array[right] >= key:
            right -= 1
        array[left], array[right] = array[right], array[left]
    array[left], array[kid] = array[kid], array[left]
    return left

2.排序程序

def QuickSort_stack(array, left, right):
    if left >= right:
        return
    stack = []
    stack.append([left, right])
    while len(stack) != 0:
        out = stack.pop()
        index = PartSort(array, out[0], out[1])
        if out[0] < index - 1:
            stack.append([out[0], index - 1])
        if index + 1 < out[1]:
            stack.append([index + 1, out[1]])

创建数字：

def ct_data(size=2 ** 5, rdm=True):
    data = np.arange(size)
    if rdm:
        np.random.shuffle(data)
    return data

3.执行：

if __name__ == '__main__':
    data = ct_data(2 ** 30, True)
    left = 0
    right = len(data) - 1
    # print(data)

    start = time.clock()
    QuickSort_stack(data, left, right)
    end = time.clock()
    print(data)
    print(end - start)

2^30=1 073 741 824，10亿级别，如果单纯用递归，一般只能到百万级别既2^15-20左右。

最终单机电脑上10亿随机数排序结果很久，但是可以执行。如果是2^50这样大，则会报内存错位。