快速排序，我好像暫時只會雙指標交換法，那種挖坑填數法晚點再研究吧。

本質也是分治+遞迴，這裡分治是相對於一個分裂點

因此，快速排序的步驟要比歸併排序多一個：分揀

先分揀，在分裂，遞迴的呼叫重複這樣一個過程

程式碼如下：

def quickSort(nums):
    # 遞迴呼叫自身進行分裂的函式，需要傳入分裂的起始和結束位置
    quickSortHelper(nums, 0, len(nums) - 1)
    return nums

def quickSortHelper(nums, first, last):

    if first < last:
        
 
# 找一個分裂點，並完成分揀
        split_point = partition(nums, first, last)
        # 呼叫自身進行排序
        quickSortHelper(nums, first, split_point)
        quickSortHelper(nums, split_point + 1, last)

def partition(nums, first, last):
    
    # 找一個基準點，定義兩個指標
    pivot = nums[first]
    left = first + 1
    right 
 
= last
    
    # 一個判斷分揀有沒有完成的flag，並去分揀
    done = False
    while not done:
        while nums[left] <= pivot and left <= right:
            left = left + 1
        while nums[right] >= pivot and left <= right:
            right = right - 1

        if left > right:
            done 
 
= True
        else:
            temp = nums[left]
            nums[left] = nums[right]
            nums[right] = temp
    
    # 當分揀完成後，讓基準點去他應該去的位置
    temp = nums[first]
    nums[first] = nums[right]
    nums[right] = temp
    
    # 把分裂點返回給遞迴函式，讓他去呼叫自身
    return right

if __name__ == "__main__":
    numbers = [4, 5, 3, 6, 8, 7, 2, 9]
    print(quickSort(numbers))

時間複雜度：O(nlogn)，但是在極端情況下會退化為O(n²)

空間複雜度：O(logn)

且快速排序是一種不穩定的排序