排序---快速排序

快速排序

1. 快速排序

快速排序（Quicksort），又稱劃分交換排序（partition-exchange sort），簡稱快排，一種排序算法，最先由東尼·霍爾提出。在平均情況下，排序n個項目要O(nlogn)次比較。在最壞情況下則須要O(n²)次比較，但這種情況並不常見。事實上，快速排序O(nlogn)一般明顯比其餘算法更快，由於它的內部循環（inner loop）能夠在大部分的架構上頗有效率地達成。詳情見快速排序【維基百科】 

 

快速排序

使用快速排序法對一列數字進行排序的過程
分類	排序算法
數據結構	不定
最壞時間複雜度
最優時間複雜度
平均時間複雜度
最壞空間複雜度	根據實現的方式不一樣而不一樣

2. 快速排序(基礎版)

#include<iostream>
#include<vector>
#include <stdlib.h>
#include <time.h>
using namespace std;

int Partition(vector<int> &array, int low, int high){
    int pivotkey = array[low]; // 優化點1
    while(low<high){
        while(low<high && array[high] >= pivotkey)
            high--;
        swap(array[low], array[high]); // 優化點2
        while(low<high && array[low] <= pivotkey)
            low++;
        swap(array[low], array[high]);
    }
    return low;
}

void QSort(vector<int> &array, int low, int high){
    int pivot;
    if(low<high){ // 優化點3
        pivot = Partition(array, low, high);
        QSort(array, low, pivot-1);
        QSort(array, pivot+1, high);
    }
}

void QuickSort(vector<int> &array){
    QSort(array, 0, array.size()-1);
}

// 判斷array是否有序
bool isOrder(vector<int> &array){
    for(int i = 1; i < array.size(); i++){
        if(array[i] < array[i-1])
            return false;
    }
    return true;
}

// 生成n個介於min，max之間的整型數
vector<int> RAND(int max, int min, int n) {
    vector<int> res;
    //srand(time(NULL)); // 註釋該行以後，每次生成的隨機數都同樣
    for(int i = 0; i < n; ++i) {
        int u = (double)rand() / (RAND_MAX + 1) * (max - min) + min;
        res.push_back(u);
    }
    return res;
}

int main(int argc, char const *argv[]) {
    vector<int> a = RAND(1, 10000, 20000000);

    clock_t start = clock();
    QuickSort(a);
    clock_t end   = clock();
    cout << "Time goes: " << (double)(end - start) / CLOCKS_PER_SEC << "sec" << endl;

    bool sorted = isOrder(a);
    cout<<sorted<<endl;
    return 0;
}

使用 20000000（2千萬）個介於1, 10000之間的數字進行測試，運行結果以下：

Time goes: 75.315sec
1
[Finished in 77.9s]

 

3. 快速排序(優化版)

#include<iostream>
#include<vector>
#include <stdlib.h>
#include <time.h>
#include <ctime>
using namespace std;

int Partition(vector<int> &array, int low, int high){
    // 優化1：使用三數區中法，有效避免pivotkey取得最大最小值
    int mid = low + (high - low) / 2;
    if(array[low] > array[high])
        swap(array[low], array[high]);
    if(array[mid] > array[high])
        swap(array[mid], array[high]);
    if(array[mid] > array[low])
        swap(array[mid], array[low]);

    int pivotkey = array[low];
    while(low < high){
        while(low < high && array[high] >= pivotkey)
            high--;
        array[low] = array[high]; // 優化2：採用指定位置賦值，減小沒必要要的交換
        while(low < high && array[low] <= pivotkey)
            low++;
        array[high] = array[low];
    }
    array[low] = pivotkey;
    return low;
}

void InsertSort2(vector<int> &array, int low, int high){
    for(int i = low+1; i <= high; i++){
        if(array[i] < array[i-1]){
            int temp = array[i];
            int j = i;
            while(j > low && temp < array[j-1]){
                array[j] = array[j-1];
                j--;
            }
            array[j] = temp;
        }
    }
}

void QSort(vector<int> &array, int low, int high){
    int pivot;
    if((high-low) > 13){
        pivot = Partition(array, low, high);
        QSort(array, low, pivot-1);
        QSort(array, pivot+1, high);
    }
    // 優化3：當元素部分有序時，切換到插入排序
    else
        InsertSort2(array, low, high);
}

bool isOrder(vector<int> &array){
    for(int i = 1; i < array.size(); i++){
        if(array[i] < array[i-1])
            return false;
    }
    return true;
}

void QuickSort(vector<int> &array){
    QSort(array, 0, array.size()-1);
}

// 生成n個介於min，max之間的整型數
vector<int> RAND(int max, int min, int n) {
    vector<int> res;
    //srand(time(NULL)); // 註釋該行以後，每次生成的隨機數都同樣
    for(int i = 0; i < n; ++i) {
        int u = (double)rand() / (RAND_MAX + 1) * (max - min) + min;
        res.push_back(u);
    }
    return res;
}

int main(int argc, char const *argv[]) {
    vector<int> a = RAND(1, 10000, 20000000);

    clock_t start = clock();
    QuickSort(a);
    clock_t end   = clock();
    cout << "Time goes: " << (double)(end - start) / CLOCKS_PER_SEC << "sec" << endl;

    bool sorted = isOrder(a);
    cout<<sorted<<endl;
    return 0;
}

使用相同的數字進行測試，運行結果以下：

Time goes: 64.458sec
1
[Finished in 66.9s]

【點擊此處查看經常使用排序算法】