一、快速排序的介紹

快速排序是一種排序演算法，對包含n個數的輸入陣列，最壞的情況執行時間為Θ(n²)[Θ 讀作theta]。雖然這個最壞情況的執行時間比較差，但快速排序通常是用於排序的最佳的實用選擇。這是因為其平均情況下的效能相當好：期望的執行時間為 Θ(nlgn)，且Θ(nlgn)記號中隱含的常數因子很小。另外，它還能夠進行就地排序，在虛擬記憶體環境中也能很好的工作。

和歸併排序一樣，快速排序也是基於分治法（Divide and conquer）：

• 分解：陣列A[p..r]被劃分成兩個(可能為空)的子陣列A[p..q-1]和A[q+1..r]，使得A[p..q-1]中的每個元素都小於等於A[q]，A[q+1..r]中的每個元素都大於等於A[q]。這樣元素A[q]就位於其最終位置上了。

• 解決：通過遞迴呼叫快速排序，對子陣列A[p..q-1]和A[q+1..r]排序。

• 合併：因為兩個子陣列是就地排序，不需要合併，整個陣列已有序。

虛擬碼：

PARTITION(A, p, r)
    x = A[p]
    i = p
    for j=p+1 to r
        do if A[j] <= x
            then i = i+1
                 exchange(A[i],A[j])
    exchange(A[p], A[i])
    return i

QUICKSORT(A, p, r)
    if p < r
        then q = PARTITION(A, p, r)
             QUICKSORT(A, p, q-1)
             QUICKSORT(A, q+1, r)
 

二、效能分析

1、最壞情況

快速排序的最壞情況發生在當陣列已經有序或者逆序排好的情況下。這樣的話劃分過程產生的兩個區域中有一個沒有元素，另一個包含n-1個元素。此時演算法的執行時間可以遞迴地表示為：T(n) = T(n-1)+T(0)+Θ(n)，遞迴式的解為T(n)=Θ(n^2)。可以看出，快速排序演算法最壞情況執行時間並不比插入排序的更好。

2、最好情況

如果我們足夠幸運，在每次劃分操作中做到最平衡的劃分，即將陣列劃分為n/2:n/2。此時得到的遞迴式為T(n) = 2T(n/2)+Θ(n)，根據主定理的情況二可得T(n)=Θ(nlgn)。

3、平均情況

假設一：快排中的劃分點非常偏斜，比如每次都將陣列劃分為1/10 : 9/10的兩個子區域，這種情況下執行時間是多少呢？執行時間遞迴式為T(n) = T(n/10)+T(9n/10)+Θ(n)

假設二：Partition所產生的劃分既有“好的”，也有“差的”，它們交替出現。這種平均情況下執行時間又是多少呢？這時的遞迴式為（G表示Good，B表示Bad）：

G(n) = 2B(n/2) + Θ(n)

B(n) = G(n-1) + Θ(n)

解：G(n) = 2(G(n/2-1) + Θ(n/2)) + Θ(n) = 2G(n/2-1) + Θ(n) = Θ(nlgn)

可以看出，當好、差劃分交替出現時，快排的執行時間就如全是好的劃分一樣，仍然是Θ(nlgn) 。

三、快排的優化

經過上面的分析可以知道，在輸入有序或逆序時快速排序很慢，在其餘情況則表現良好。如果輸入本身已被排序，那麼就糟了。那麼我們如何確保對於所有輸 入，它均能夠獲得較好的平均情況效能呢？前面的快速排序我們預設使用陣列中第一個元素作為主元。假設隨機選擇陣列中的元素作為主元，則快排的執行時間將不 依賴於輸入序列的順序。我們把隨機選擇主元的快速排序叫做Randomized Quicksort。

在隨機化的快速排序中，我們不是始終選擇第一個元素作為主元，而是從陣列A[p…r]中隨機選擇一個元素，然後將其與第一個元素交換。由於主元元素是隨機選擇的，我們期望在平均情況下，對輸入陣列的劃分能夠比較對稱。

虛擬碼：

RANDOMIZED-PARTITION(A, p, r)
    i = RANDOM(p, r)
    exchange(A[p], A[i])
    return PARTITION(A, p, r)

RANDOMIZED-QUICKSORT(A, p, r)
    if p < r
        then q = RANDOMIZED-PARTITION(A, p, r)
            RANDOMIZED-QUICKSORT(A, p, q-1)
            RANDOMIZED-QUICKSORT(A, q+1, r)

我們對3萬個元素的有序序列分別進行傳統的快速排序 和 隨機化的快速排序，並比較它們的執行時間：

/*************************************************************************
    > File Name: QuickSort.cpp
    > Author: SongLee
    > E-mail: [email protected]
    > Created Time: 2014年06月21日 星期六 10時11分30秒
    > Personal Blog: http://songlee24.github.com
 ************************************************************************/
#include<iostream>
#include<cstdlib>  // srand rand
#include<ctime>  // clock_t clock
using namespace std;

void swap(int &a, int &b)
{
    int tmp = a;
    a = b;
    b = tmp;
}

// 傳統劃分操作
int Partition(int A[], int low, int high)
{
    int pivot = A[low];
    int i = low;
    for(int j=low+1; j<=high; ++j)
    {
        if(A[j] <= pivot)
        {
            ++i;
            swap(A[i], A[j]);
        }
    }
    swap(A[i], A[low]);
    return i;
}

// 隨機化劃分操作，隨機選擇pivot
int Partition_Random(int A[], int low, int high)
{
    srand(time(NULL));
    int i = rand() % (high+1);
    swap(A[low], A[i]);
    return Partition(A, low, high);
}

// 傳統快排
void QuickSort(int A[], int low, int high)
{
    if(low < high)
    {
        int pos = Partition(A, low, high);
        QuickSort(A, low, pos-1);
        QuickSort(A, pos+1, high);
    }
}

// 隨機化快速排序
void QuickSort_Random(int A[], int low, int high)
{
    if(low < high)
    {
        int pos = Partition_Random(A, low, high);
        QuickSort_Random(A, low, pos-1);
        QuickSort_Random(A, pos+1, high);
    }
}

int main()
{
    clock_t t1, t2;
    // 初始化陣列
    int A[30000];
    for(int i=0; i<30000; ++i)
        A[i] = i+1;
        
    t1 = clock();
    QuickSort(A, 0, 30000-1);
    t1 = clock() - t1;
    cout << "Traditional quicksort took "<< t1 << " clicks(about " << ((float)t1)/CLOCKS_PER_SEC << " seconds)." << endl;

    t2 = clock();
    QuickSort_Random(A, 0, 30000-1);
    t2 = clock() - t2;
    cout << "Randomized quicksort took "<< t2 << " clicks(about " << ((float)t2)/CLOCKS_PER_SEC << " seconds)." << endl;

    return 0;
}

執行結果：

[[email protected] ~]$ ./QuickSort 
Traditional quicksort took 1210309 clicks(about 1.21031 seconds).
Randomized quicksort took 457573 clicks(about 0.457573 seconds).
[[email protected] ~]$ ./QuickSort 
Traditional quicksort took 1208038 clicks(about 1.20804 seconds).
Randomized quicksort took 644950 clicks(about 0.64495 seconds).

問題記錄：

我們知道交換兩個變數的值有以下三種方法：

int tmp = a;  // 方法一
a = b;
b = tmp

a = a+b;  // 方法二
b = a-b;
a = a-b;

a = a^b;  // 方法三
b = a^b;
a = a^b;

但是你會發現在本程式中，如果swap函式使用後面兩種方法會出錯。由於方法二和方法三沒有使用中間變數，它們交換值的原理是直接對變數的記憶體單元進行操作。如果兩個變數對應的同一記憶體單元，則經過兩次加減或異或操作，記憶體單元的值已經變為了0，因而不能實現變數值交換。所以當需要交換值的變數可能是同一變數時，必須使用第三變數實現交換，否則會對變數清零。