排序（四） 快速排序

原始快速排序：选取最左边元素作为标准，将所有小于它的元素放在左边，大于它的元素放在右边

# 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)

重复键值很多时，三路快速排序效果显著