2020/7/30

一种快速排序算法的非递归实现（python版）

import numpy as np
import matplotlib.pyplot as plot
import copy
import time


def main():
    arr = [x for x in np.random.choice(10, 5000, replace=True)]
    arr_2 = copy.deepcopy(arr)
    
    b1 = time.clock()
    sort_2(arr_2, 0, len(arr)-1)
    e1 = time.clock()

    b2 = time.clock()
    sort(arr, 0, len(arr)-1)
    e2 = time.clock()

    plot.figure("sort")
    plot.subplot(221)
    plot.title(str(e1 - b1))
    plot.bar([x for x in range(len(arr))], arr)
    
    plot.subplot(222)
    plot.title(str(e2 - b2))
    plot.bar([x for x in range(len(arr_2))], arr_2)
    
    plot.show()

def sort(arr, left, right):
    stack = []
    if left >= right: return

    benckmark = partition(arr, left, right)
    if right - left <= 1: return

    stack.append([left, benckmark-1])
    stack.append([benckmark+1, right])

    while len(stack) != 0:
        e = stack.pop()
        if (e[0] >= e[1]): continue
        tmp_benckmark = partition(arr, e[0], e[1])

        stack.append([e[0], tmp_benckmark-1])
        stack.append([tmp_benckmark+1, e[1]])

def sort_2(arr, left, right):
    stack = []
    if left >= right: return
    i, j = partition_2(arr, left, right)

    stack.append([left, i-1])
    stack.append([j+1, right])

    while len(stack) != 0:
        e = stack.pop()
        if e[0] >= e[1]:continue
        tmp_i, tmp_j = partition_2(arr, e[0], e[1])
        stack.append([e[0], tmp_i-1])
        stack.append([tmp_j+1, e[1]])

def partition_2(arr, left, right):
    b = arr[left]
    i,m,j = left, left+1, right

    while m<=j:
        if b == arr[m]: m=m+1
        elif b > arr[m]: 
            arr[m], arr[i] = arr[i], arr[m]
            m = m+1
            i = i+1
        elif b < arr[m]:
            arr[m], arr[j] = arr[j], arr[m]
            j = j-1
    
    return i,j

def partition(arr, left, right):
    benchmark = arr[left]

    i, j = left+1, right

    while True:
        while benchmark >= arr[i]:
            i = i+1
            if i >= right: break
        
        while benchmark < arr[j]:
            j = j-1
            if j <= left: break
        
        if i >= j: break
        arr[i], arr[j] = arr[j], arr[i]
    arr[left], arr[j] = arr[j], arr[left]
    return j

if __name__ == '__main__':
    main()