快速排序算法（三種分區方法要熟練！）

快排確實厲害！！！

總的思想是分治遞歸，取定一個值作為標簽，比該值小的去左邊，比該值大的去右邊。

單向掃描分區法：

 

去左邊的操作：只將sp++即可。

去右邊的操作：具體是將sp指向的值與bigger指向的值交換。

考慮邊界：當掃描指針sp與bigger相等時，再執行一次循環后，sp剛好在bigger的右邊一格。

/*
 * 快速排序算法
 */
void swp(int arr[], int n, int m)
{
    int temp = arr[n];
    arr[n] = arr[m];
    arr[m] = temp;
}
int Part(int arr[], int p, int r)
{
    int pivot = arr[p]; // 定中間數
    int sp = p + 1;   // 掃描指針
    int bigger = r;   // 右側指針
    while (sp <= bigger)
    {
        if (arr[sp] > pivot) {
            swp(arr, sp, bigger);
            bigger--;
        }
        else
            sp++;
    }
    swp(arr, p, bigger);
    return bigger;
}
void quickSort(int arr[], int p, int r)
{
    int q = 0;
    if (p < r) {
        // 分區：小於的數移動到左邊，大於的數移動到右邊
        q = Part(arr, p, r);
        // 將排序問題分治
        quickSort(arr, p, q - 1);
        quickSort(arr, q + 1, r);
    }
}
int main()
{
    int ar[2] = {1, -1};
    quickSort(ar, 0, 1);
    // 打印
    for (int i = 0; i <= 1; i++)
        cout << ar[i] << endl;
    return 0;
}

雙向掃描分區法：

與單向掃描分區類似，但left指針一直往右移，直到大於中間值時停止；right指針一直往左移，直到小於中間值時停止。然后left值與right值交換。之后left繼續一直左移，right一直右移。重復執行。

小心：left一直左移（或right一直右移）導致的數組越界問題。

/*
 * 快速排序算法
 */
void swp(int arr[], int n, int m)
{
    int temp = arr[n];
    arr[n] = arr[m];
    arr[m] = temp;
}
int Part(int arr[], int p, int r)
{
    int pivot = arr[p]; // 定中間數
    int left = p + 1;  // 左指針
    int right = r;     // 右指針
    // 雙向掃描核心
    while (left <= right)
    {
        while (left <= right && arr[left] <= pivot) left++;
        while (left <= right && arr[right] > pivot) right--;
        if (left < right)
            swp(arr, left, right);
    }
    swp(arr, p, right);
    return right;
}
void quickSort(int arr[], int p, int r)
{
    int q = 0;
    if (p < r) {
        // 分區：小於等於的數移動到左邊，大於的數移動到右邊
        q = Part(arr, p, r);
        // 將排序問題分治
        quickSort(arr, p, q - 1);
        quickSort(arr, q + 1, r);
    }
}
int main()
{
    int ar[8] = {2, 3, 3, 3, 45, 8, 4, 6};
    quickSort(ar, 0, 7);
    // 打印
    for (int i = 0; i <= 7; i++)
        cout << ar[i] << " ";
    return 0;
}

三指針分區法：

三指針分區法對於相等元素較多的數組能提升一定的效率。

Next_Less_Pos指針始終指向數組的相等區第一個元素；Next_Scan_Pos指針始終指向要掃描區域的第一個元素；Next_Bigger_Pos指針的右區域所有元素總大於主元。

/*
 * 快速排序算法
 */
void swp(int arr[], int n, int m)
{
    int temp = arr[n];
    arr[n] = arr[m];
    arr[m] = temp;
}
void Part(int arr[], int p, int &e, int &bigger)
{
    int pivot = arr[p]; // 定中間數
    int s = e;
    // 三指針分區核心
    while (s <= bigger) {
        if (arr[s] < pivot) { 
            swp(arr, s, e);
            s++; e++;
        }
        else if (arr[s] > pivot) {
            swp(arr, s, bigger);
            bigger--;
        }
        else s++; 
    }
    swp(arr, e - 1, p);
}
void quickSort(int arr[], int p, int r)
{
    int left = p + 1, right = r;
    if (p < r) {
        // 分區：小於的數移動到左邊，大於的數移動到右邊，等於的數在中間
        Part(arr, p, left, right);
        // 將排序問題分治
        if (left > p) quickSort(arr, p, left - 1);
        if (right < r) quickSort(arr, right + 1, r);
    }
}
int main()
{
    int ar[20];
    srand((unsigned)time(nullptr));
    for (int i = 0; i <= 19; i++)
        ar[i] = rand() % (10 - 1 + 1) + 1;
    quickSort(ar, 0, 19);
    // 打印
    for (int i = 0; i <= 19; i++)
        cout << ar[i] << " ";
    return 0;
}

小心邊界：必須是相等區域的前一個小於元素，和相等區域的后一個大於元素（即 left - 1 和 right + 1），這時能避免無限循環。

但在避免無限循環的同時，又得保證邊界下標的合理性，故我們此時加 if 語句判斷。

 

補充 工程實踐中的一些優化：

• 三點中值法（去首元素、尾元素和中間元素，取三元素的中間值作為主元）
• 絕對中值法（花費 O(n) 的時間，尋找中間值作為主元）
• 部分插入排序（在遞歸樹中，對於元素較少的部分直接用插入排序）