主要思想是：每次把待排序陣列分為兩部分，左邊小於軸右邊大於軸，把分開的陣列的收尾陣列的索引存到輔助棧空間裡，替換遞迴。兩種思路：

思路一:嚴老師資料結構裡面的思路

def partition(nums,low,high):
        high_flag = True
        low_flag = False
        pivot = nums[low]
        while low < high and low < len(nums) and high < len(nums):
            if high_flag:
                if nums[high] < pivot:
                    nums[low] = nums[high]
                    high_flag = False
                    low_flag = True
                else:
                    high -= 1
            if low_flag:
                if nums[low] > pivot:
                    nums[high] = nums[low]
                    high_flag = True
                    low_flag = False
                else:
                    low += 1
        nums[low] = pivot
        print(low)
        return low
def quickSort(nums):
    arr = []
    low = 0
    high = len(nums) -1
    if low < high:
        mid = partition(nums,low,high)
        if low < mid - 1:
            arr.append(low)
            arr.append(mid-1)
        if mid+1 < high:
            arr.append(mid+1)
            arr.append(high)
        while arr:
            r = arr.pop()
            l = arr.pop()
            mid = partition(nums,l,r)
            if l < mid -1:
                arr.append(l)
                arr.append(mid-1)
            if mid + 1 < r:
                arr.append(mid + 1)
                arr.append(r)
    print(nums)
 

思路二：演算法導論裡面的

def quick_sort_other(array, l, r):
    '''
    演算法導論裡的思想
    i表示[l,i]都比pivot小
    j依次遍歷元素

    '''
    if l >= r:
        return
    stack = [l,r]
    while stack:
        low = stack.pop(0)
        high = stack.pop(0)
        if high <= low:
            continue
        pivot = array[high]
        i = low - 1 ###初始值是-1
        for j in range(low,high+1):
            ###如果小於pivot， 則交換，交換的目的是保證[l,i]都比pivot小
            if array[j] <= pivot:
                i += 1
                t = array[i]
                array[i] = array[j]
                array[j] = t
        stack.extend([low, i-1, i + 1, high])
    return arrays