冒泡排序 vs 快速排序 vs 归并排序

#include <iostream>
#include <vector>
#include <stdlib.h>
#include <chrono>
#include <cmath>
#include <algorithm>
template <typename T> 
inline void swap(T * t1, T * t2) {
    T tmp = *t1;
    *t1 = *t2;
    *t2 = tmp;
}

template <typename T>
void quicksort(std::vector<T> & vec, int sortBegin, int sortEnd) {
    if (sortEnd == sortBegin) return;
    if (sortEnd - sortBegin == 1) {
        if (vec[sortBegin] > vec[sortEnd]) swap(&vec[sortBegin], &vec[sortEnd]);
        return;
    }
    int i = sortBegin, j = sortEnd;
    auto pivot = vec[i];
    int Index = -1;
    while(true) {
        while(i != j && vec[j] > pivot) j--;
        if (i == j ) {
            Index = i;
            break;
        }
        vec[i++] = vec[j];
        while(i != j && vec[i] < pivot) i++;
        if (i == j ) {
            Index = i;
            break;
        }
        vec[j--] = vec[i];
    }
    vec[Index] = pivot;
    if (Index == sortBegin) {
        quicksort(vec, Index+1, sortEnd);
    } else if (Index == sortEnd) {
        quicksort(vec, sortBegin, Index-1);
    } else {
        quicksort(vec, sortBegin, Index-1);
        quicksort(vec, Index+1, sortEnd);
    }
}

template <typename T>
void bubblesort(std::vector<T> & vec) {
    // n -1 次
    for (int i = vec.size() - 2 ; i >= 0 ; i-- ) {
        // 0 -> 1 ， 1-> 2, ....., i -> i+1
        for (int j = 0; j <= i ; j++) {
            if (vec[j] > vec[j+1]) {
                swap<T>(&vec[j], &vec[j+1]);
            }
        }
    }
}

template <typename T>
void mergesort(std::vector<T> & vec) {
    if (vec.size() == 1) {
        return;
    }
    if (vec.size() == 2) {
        if(vec[0] > vec[1]) {
            swap(&vec[0], &vec[1]);
        }
        return;
    }
    auto Index = (vec.size() - 1)/ 2;
    std::vector<T> vec1 = {vec.begin(), vec.begin() + Index};
    std::vector<T> vec2 = {vec.begin() + Index, vec.end()};
    mergesort(vec1);
    mergesort(vec2);
    // insert
    int index1 = 0, index2 = 0, index = 0;
    while(true) {
        if(index == vec.size() ) {
            break;
        }
        if(index1 == vec1.size()) {
            while(index2 < vec2.size()) {
                vec[index++] = vec2[index2++];
            }
        }
        else if(index2 == vec2.size()) {
            while(index1 < vec1.size()) {
                vec[index++] = vec1[index1++];
            }
        }
        else if(vec1[index1] < vec2[index2]) {
            vec[index++] = vec1[index1++];
        } else {
            vec[index++] = vec2[index2++];
        }
    }
}


void genertor(std::vector<int> &vec, int max) {
    for (auto & item : vec) {
        item = rand() % max;
    }
}

int main() {
    std::vector<int> vec;
    constexpr int maxpow = 6;
    for (int i = 1; i < maxpow; i++) {
        auto size = pow(10, i);
        vec.resize(size);
        genertor(vec, size);
        auto startTime = std::chrono::high_resolution_clock::now();
        bubblesort(vec);
        auto endTime = std::chrono::high_resolution_clock::now();
        std::chrono::duration<double, std::milli> diffTime = endTime - startTime;
        std::cout << "size: " << size << ", bubble sort timecost = " << diffTime.count() << "ms" << std::endl;
    }
    for (int i = 1; i < maxpow ; i++) {
        auto size = pow(10, i);
        vec.resize(size);
        genertor(vec, size);
        auto startTime = std::chrono::high_resolution_clock::now();
        quicksort(vec, 0, size-1);
        auto endTime = std::chrono::high_resolution_clock::now();
        std::chrono::duration<double, std::milli> diffTime = endTime - startTime;
        std::cout << "size: " << size << ", quick sort timecost = " << diffTime.count() << "ms" << std::endl;
    }

    for (int i = 1; i < maxpow ; i++) {
        auto size = pow(10, i);
        vec.resize(size);
        genertor(vec, size);
        auto startTime = std::chrono::high_resolution_clock::now();
        mergesort(vec);
        auto endTime = std::chrono::high_resolution_clock::now();
        std::chrono::duration<double, std::milli> diffTime = endTime - startTime;
        std::cout << "size: " << size << ", merge sort timecost = " << diffTime.count() << "ms" << std::endl;
    }
    return 0;
}

结果：

size: 10, bubble sort timecost = 0.000986ms
size: 100, bubble sort timecost = 0.058162ms
size: 1000, bubble sort timecost = 5.81554ms
size: 10000, bubble sort timecost = 489.622ms
size: 100000, bubble sort timecost = 51133.3ms
size: 10, quick sort timecost = 0.000635ms
size: 100, quick sort timecost = 0.018426ms
size: 1000, quick sort timecost = 0.099007ms
size: 10000, quick sort timecost = 1.39961ms
size: 100000, quick sort timecost = 17.7071ms
size: 10, merge sort timecost = 0.020368ms
size: 100, merge sort timecost = 0.119247ms
size: 1000, merge sort timecost = 0.972509ms
size: 10000, merge sort timecost = 11.4218ms
size: 100000, merge sort timecost = 129.984ms