冒泡排序和快速排序

冒泡排序：

#include <iostream>
#include <vector>

using namespace std;

// 冒泡排序
void bubbleSort(vector<int>& arr){
    if(arr.empty())
        return;
    // 外循环n-1次
    // 循环一次的结果：将最大的元素通过多次交换挪至最后的位置
    for(int i = 1; i < arr.size(); ++i){
        for(int j = 0; j < arr.size()-i; ++j){
            if(arr[j] > arr[j+1])
                swap(arr[j], arr[j+1]);
        }
    }
}

快速排序：

#include <iostream>
#include <vector>

using namespace std;

// [l,r]左闭右闭区间进行Partition操作
int _partition(vector<int>& arr, int l, int r){
    // 选择最左侧元素作为分割点
    int target = arr[l];
    // arr[l+1...j] < target ; arr[j+1...i) >= target
    // j是左半部分的最后一个元素的索引
    int j = l;
    for(int i = l + 1; i <= r; ++i)
        if(arr[i] < target){
            ++j;
            swap(arr[j], arr[i]);
        }
    // 最后将target与左半部分最后一个元素互换
    swap(arr[l], arr[j]);

    return j;
}

// 对arr[l...r]部分进行快速排序
void _quickSort(vector<int>& arr, int l, int r){
    if(l >= r)
        return;

    int p = _partition(arr, l, r);
    _quickSort(arr, l, p-1);
    _quickSort(arr, p+1, r);
}

void quickSort(vector<int>& arr){
    // arr.size() 是size_t类型，当arr.size() == 0时，arr.size()-1可不是-1哦
    if(arr.empty())
        return;

    _quickSort(arr, 0, arr.size()-1);
}

int main(){
    // 测试
    vector<int> arr{3,9,1,2,4,3,2,7};
    quickSort(arr);
    for(auto c : arr)
        cout << c << "  ";
    cout << endl;

    return 0;
}

随机快速排序：在快速排序的基础上，只有一处改动，就是在Partition时，随机选择了一个元素作为target，仅此而已。

#include <iostream>
#include <vector>
#include <algorithm>
#include <ctime>

using namespace std;

// [l,r]左闭右闭区间进行Partition操作
int _partition(vector<int>& arr, int l, int r){
    // 随机在arr[l...r]的范围中, 选择一个数值作为标定点pivot
    swap(arr[l], arr[rand()%(r-l+1)+l]);
    // 选择最左侧元素作为分割点
    int target = arr[l];

    // arr[l+1...j] < target ; arr[j+1...i) >= target
    // j是左半部分的最后一个元素的索引
    int j = l;
    for(int i = l + 1; i <= r; ++i)
        if(arr[i] < target){
            ++j;
            swap(arr[j], arr[i]);
        }
    // 最后将target与左半部分最后一个元素互换
    swap(arr[l], arr[j]);

    return j;
}

// 对arr[l...r]部分进行快速排序
void _quickSort(vector<int>& arr, int l, int r){
    if(l >= r)
        return;

    int p = _partition(arr, l, r);
    _quickSort(arr, l, p-1);
    _quickSort(arr, p+1, r);
}

void quickSort(vector<int>& arr){
    // arr.size() 是size_t类型，当arr.size() == 0时，arr.size()-1可不是-1哦
    if(arr.empty())
        return;
    srand(time(NULL));
    _quickSort(arr, 0, arr.size()-1);
}

int main(){
    vector<int> arr{3,9,1,2,4,99,23,12,8};

    quickSort(arr);
    for(auto c : arr)
        cout << c << "  ";
    cout << endl;

    return 0;
}

双路快速排序：对于含有大量重复元素的数组，随机快排Partition的左右部分长度可能相差很大，使用双路快排能够尽量维护Partition后左右部分长度相当，从而提高效率。

#include <iostream>
#include <vector>
#include <algorithm>
#include <ctime>

using namespace std;

int _partition(vector<int>& arr, int l, int r){

    // 随机
    swap( arr[l] , arr[rand()%(r-l+1)+l] );
    int target = arr[l];

    // arr[l+1...i) <= target; arr(j...r] >= target
    int i = l + 1;
    int j = r;
    while( true ){
        // 注意边界, arr[i] < target, 不能是arr[i] <= target
        // 为了保持Partition后两部分长度不至于相差太大
        while( i <= r && arr[i] < target )
            i ++;

        // 注意边界, arr[j] > target, 不能是arr[j] >= target
        while(j >= l+1 && arr[j] > target)
            --j;

        if(i > j)
            break;

        swap(arr[i], arr[j]);
        ++i;
        --j;
    }
    swap(arr[l], arr[j]);

    return j;
}


// 对arr[l...r]部分进行快速排序
void _quickSort(vector<int>& arr, int l, int r){
    if(l >= r)
        return;

    int p = _partition(arr, l, r);
    _quickSort(arr, l, p-1);
    _quickSort(arr, p+1, r);
}

void quickSort(vector<int>& arr){
    // arr.size() 是size_t类型，当arr.size() == 0时，arr.size()-1可不是-1哦
    if(arr.empty())
        return;
    srand(time(NULL));
    _quickSort(arr, 0, arr.size()-1);
}



int main(){
    srand(time(NULL));

    vector<int> arr{3,9,1,2,8,8,8,4,99,23,12,8,8,8,8,8,8};
    quickSort(arr);
    for(auto c : arr)
        cout << c << "  ";
    cout << endl;

    return 0;
}

三路快速排序：Partition操作不再只分成两部分了，而是分成三部分，小于target的部分，等于target的部分，大于target的部分。

#include <iostream>
#include <algorithm>
#include <ctime>
#include <vector>

using namespace std;

void _quickSort3Ways(vector<int>& arr, int l, int r){
    if(l >= r)
        return;

    swap(arr[l], arr[rand()%(r-l+1)+l]);
    int target = arr[l];
    // l:left, le:left-end, r:right, rs:right-start
    int le = l;     // arr[l+1...le] < target
    int rs = r + 1; // arr[rs...r] > target
    int i = l+1;    // arr[le+1...rs) == target

    while(i < rs){
        if(arr[i] < target){
            swap(arr[i], arr[le+1]);
            ++i;
            ++le;
        }
        else if(arr[i] > target){
            swap(arr[i], arr[rs-1]);
            --rs;
        }
        else{ // arr[i] == target部分
            ++i;
        }
    }

    swap(arr[l], arr[le]);

    _quickSort3Ways(arr, l, le-1);
    _quickSort3Ways(arr, rs, r);
}

void quickSort3Ways(vector<int>& arr){
    srand(time(NULL));
    if(arr.empty())
        return;
    _quickSort3Ways(arr, 0, arr.size()-1);
}


int main(){

    vector<int> arr{3,9,1,2,8,8,8,4,99,23,12,8,8,8,8,8,8};
    quickSort3Ways(arr);
    for(auto c : arr)
        cout << c << "  ";
    cout << endl;

    return 0;
}