原始快速排序：選取最左邊元素作為標準，將所有小於它的元素放在左邊，大於它的元素放在右邊

# quick_sort.py

# [l,r]
def swap(a,b):
    return b,a

def __partition(array,l,r):
    e = array[l]
    j = l
    for i in range(l+1,r+1):
        if(array[i]<e):
            array[i], array[j + 1] = swap(array[i],array[j+1])
            j+=1
        i+=1
    array[l], array[j] = swap(array[l],array[j])
    return j

def __quickSort(array,l,r):
    if(l>=r):
        return;
    p = __partition(array,l,r)
    __quickSort(array,l,p-1)
    __quickSort(array,p+1,r)

def quickSort(array,n):
    __quickSort(array,0,n-1)
 

當數列幾乎為有序數列時，導致樹不平衡，退化為O(n²) 

隨機快速排序：選取隨機元素，選其作為標準，與最左邊元素交換。將所有小於它的元素放在左邊，大於它的元素放在右邊

# quick_sort_random.py

import random
# [l,r]
def swap(a,b):
    return b,a

def __partition(array,l,r):
    array[l], array[random.randint(l, r)] = swap(array[l],array[random.randint(l,r)])

    e = array[l]
    j = l
    for i in range(l+1,r+1):
        if(array[i]<e):
            array[i], array[j + 1] = swap(array[i],array[j+1])
            j+=1
        i+=1
    array[l], array[j] = swap(array[l],array[j])
    return j

def __quickSort(array,l,r):
    if(l>=r):
        return;
    p = __partition(array,l,r)
    __quickSort(array,l,p-1)
    __quickSort(array,p+1,r)

def quickSort(array,n):
    __quickSort(array,0,n-1)
 

 重複鍵值過多時，樹不平衡，退化為O(n²)

雙路快速排序：首尾兩指標，小於標準左放，大於標準右放

# quick_sort2.py

import random
# [l,r]

def swap(a,b):
    return b,a

def __partition2(array,l,r):
    array[l], array[random.randint(l, r)] = swap(array[l],array[random.randint(l,r)])

    e = array[l]
    i = l+1
    j = r
    while(1):
        while((i<=r) and (array[i]<e)):
            i+=1
        while((j>=l+1) and (array[j]>e)):
            j-=1
        if(i>j):
            break
        array[i],array[j] = swap(array[i],array[j])
        i+=1
        j-=1
    array[l],array[j] = swap(array[l],array[j])
    return j


def __quickSort2(array,l,r):
    if(l>=r):
        return;
    p = __partition2(array,l,r)
    __quickSort2(array,l,p-1)
    __quickSort2(array,p+1,r)

def quickSort2(array,n):
    __quickSort2(array,0,n-1)
 

三路快速排序：三指標，gt == i時，最左元素與最後一個小於它的元素（lt指向）交換

# quick_sort3ways.py

import random

def swap(a,b):
    return b,a

def __partition(array,l,r):
    array[l],array[random.randint(l,r)] = swap(array[l],array[random.randint(l,r)])

    e = array[l]
    i = l+1 # array[lt+1...i)==e
    lt = l # array[l+1...lt]<e
    gt = r+1 # array[gt...r]>e
    while(i<gt):
        if(array[i]<e):
            array[lt+1],array[i] = swap(array[lt+1],array[i])
            i+=1
            lt+=1
        elif(array[i]==e):
            i+=1
        else:
            array[gt-1],array[i] = swap(array[gt-1],array[i])
            gt-=1
    array[l],array[lt] = swap(array[l],array[lt])
    return lt,gt

def __quickSort3Ways(array,l,r):
    if(l>=r):
        return;
    p1,p2 = __partition(array,l,r)
    __quickSort3Ways(array,l,p1-1)
    __quickSort3Ways(array,p2,r)

def quickSort3Ways(array,n):
    __quickSort3Ways(array,0,n-1)

重複鍵值很多時，三路快速排序效果顯著