基於快速排序演算法的C++排序函數

排序是計算機科學中最基本的問題之一。在計算機程序中，排序演算法是最常用的演算法之一。排序演算法指定對一個大小為N的列表或數組進行重排某一順序，通常為數字或字母的升序或降序。

一、快速排序是最穩定的排序演算法

快速排序是最穩定的排序演算法之一，也是最經典最常用的排序演算法之一。主要思路是利用「分治法」的思想，將原序列逐步分解成多個子序列，最終將所有子序列的排序合併成整個序列的有序排列。

void quicksort(int* arr, const int left, const int right) {
    if (left < right) {
        int i = left, j = right, mid = arr[(i + j) / 2];
        while (i <= j) {
            while (arr[i]  mid) j--;
            if (i <= j) {
                swap(arr[i], arr[j]);
                i++;
                j--;
            }
        }
        quicksort(arr, left, j);
        quicksort(arr, i, right);
    }
}

快速排序的時間複雜度通常為O(nlogn)，是排序演算法中的高效演算法之一。

二、為實現快速排序演算法

下面是利用快速排序演算法實現數組排序的C++代碼：

#include <iostream>
using namespace std;

void quicksort(int* arr, const int left, const int right);

int main() {
    int arr[8] = {5, 3, 8, 6, 2, 7, 4, 1};
    int len = sizeof(arr) / sizeof(*arr);
    quicksort(arr, 0, len - 1);
    for (int i = 0; i < len; i++)
        cout << arr[i] << " ";
    cout << endl;
    return 0;
}

void quicksort(int* arr, const int left, const int right) {
    if (left < right) {
        int i = left, j = right, mid = arr[(i + j) / 2];
        while (i <= j) {
            while (arr[i] < mid) i++;
            while (arr[j] > mid) j--;
            if (i <= j) {
                swap(arr[i], arr[j]);
                i++;
                j--;
            }
        }
        quicksort(arr, left, j);
        quicksort(arr, i, right);
    }
}

三、待排序序列、合併排序和快速排序演算法比較

待排序的序列是指未排序的序列，合併排序和快速排序演算法是排序演算法中常用的演算法。

快速排序演算法的時間複雜度為nlogn，而合併排序呢？在最壞的情況下，合併排序的時間複雜度為o(nlogn)。在最好的情況下，快速排序的時間複雜度為O(nlogn)。因此，它被稱為最快的排序演算法之一。

合併排序的時間複雜度的主要缺點是需要額外存儲空間（O（N）），而快速排序不需要。然而，在實踐中，它們的差異很小，並且它們比內部排序演算法（例如，插入排序和選擇排序）更快。

在大多數情況下，快速排序是最優的選擇。

四、快速排序演算法第一次排序

下面是快速排序演算法第一次排序的C++代碼：

#include <iostream>
using namespace std;

void quicksort(int* arr, const int left, const int right);

int main() {
    int arr[8] = {5, 3, 8, 6, 2, 7, 4, 1};
    int len = sizeof(arr) / sizeof(*arr);
    quicksort(arr, 0, len - 1);
    for (int i = 0; i < len; i++)
        cout << arr[i] << " ";
    cout << endl;
    return 0;
}

void quicksort(int* arr, const int left, const int right) {
    if (left < right) {
        int i = left, j = right, mid = arr[(i + j) / 2];
        while (i <= j) {
            while (arr[i] < mid) i++;
            while (arr[j] > mid) j--;
            if (i <= j) {
                swap(arr[i], arr[j]);
                i++;
                j--;
            }
        }
        quicksort(arr, left, j);
        quicksort(arr, i, right);
    }
}

五、快速排序是排序演算法中最快的演算法嗎？

快速排序是最快的外部排序演算法之一。但是，在內部排序中，它並不總是最快的，取決於序列的特徵。在最壞情況下，快速排序的時間複雜度為O（n²），而合併排序的時間複雜度始終是O（nlogn）。

可以得到這樣一個結論：在所有排序演算法中，快速排序中使用的主元分割技術在平均情況下具有最好的性能，並且在大多數情況下是最優解的選擇。另一方面，希爾排序通常用於數組中的小部分（例如，10或20）元素。

下面是快速排序演算法的C++代碼：

#include <iostream>
using namespace std;

void quicksort(int* arr, const int left, const int right);

int main() {
    int arr[8] = {5, 3, 8, 6, 2, 7, 4, 1};
    int len = sizeof(arr) / sizeof(*arr);
    quicksort(arr, 0, len - 1);
    for (int i = 0; i < len; i++)
        cout << arr[i] << " ";
    cout << endl;
    return 0;
}

void quicksort(int* arr, const int left, const int right) {
    if (left < right) {
        int i = left, j = right, mid = arr[(i + j) / 2];
        while (i <= j) {
            while (arr[i] < mid) i++;
            while (arr[j] > mid) j--;
            if (i <= j) {
                swap(arr[i], arr[j]);
                i++;
                j--;
            }
        }
        quicksort(arr, left, j);
        quicksort(arr, i, right);
    }
}

綜上所述，快速排序演算法是最快的外部排序演算法之一，並且在內部排序演算法中，雖然不總是最快的演算法，但在大多數情況下是最優解的選擇。