C++排序算法（高性能）

Sort algorithm in C++

快速排序

//三数中值法
template <typename T>
const T& partition(vector<T> &vec, int left, int right){
    int center = (left + right)/2;

    if(vec[center] < vec[left])
        std::swap(vec[left], vec[center]);
    if(vec[right] < vec[left])
        std::swap(vec[left], vec[right]);
    if(vec[right] < vec[center])
        std::swap(vec[center], vec[right]);
    std::swap(vec[center], vec[right-1]);
    return vec[right-1];
}

template <typename T>
void quick_sort(vector<T> &vec, int left, int right){
    if(left >= right)
        return;
    const T &pivot = partition(vec, left, right);
    int i = left, j = right-1;
    while (1){
        while(vec[++i] < pivot){}
        while(j > left && pivot < vec[--j]){}//注意j > left
        if(i < j)//注意
            std::swap(vec[i],vec[j]);
        else
            break;
    }
    if(i < right)
        std::swap(vec[i], vec[right-1]);

    quick_sort(vec, left, i-1);
    quick_sort(vec, i+1, right);
}

归并排序

template <typename T>
void merge(vector<T> &vec, vector<T> &tmp, int left_pos, int right_pos, int right_end){
    int left_end = right_pos-1;
    int tmp_pos = left_pos;
    int num = right_end - left_pos + 1;

    while (left_pos <= left_end && right_pos <= right_end){
        if(vec[left_pos] <= vec[right_pos])
            tmp[tmp_pos++] = std::move(vec[left_pos++]);
        else
            tmp[tmp_pos++] = std::move(vec[right_pos++]);
    }

    while (left_pos <= left_end)
        tmp[tmp_pos++] = std::move(vec[left_pos++]);
    while(right_pos <= right_end)
        tmp[tmp_pos++] = std::move(vec[right_pos++]);

    for(int i = 0; i < num; ++i, --right_end)
        vec[right_end] = std::move(tmp[right_end]);
}

template <typename T>
void merge_sort(vector<T> &vec, vector<T> &tmp, int left, int right){
    if(left < right){
        int center = (left + right)/2;
        merge_sort(vec, tmp, left, center);
        merge_sort(vec, tmp, center+1, right);
        merge(vec, tmp, left, center+1, right);
    }
}

堆排序

template <typename T>
void perc_down(vector<T> &vec, int i, int n){
    int child;
    T tmp;
    for(tmp = std::move(vec[i]); 2*i+1 < n; i = child){
        child = 2*i+1;
        if(child != n-1 && vec[child] < vec[child + 1])
            ++child;
        if(tmp < vec[child])
            vec[i] = std::move(vec[child]);
        else
            break;
    }
    vec[i] = std::move(tmp);
}

template <typename T>
void heap_sort(vector<T> &vec){
    for(int i = vec.size() / 2 - 1; i >= 0; --i){
        perc_down(vec, i, vec.size());
    }
    for(int i = vec.size()-1; i > 0; --i){
        std::swap(vec[0], vec[i]);
        perc_down(vec, 0, i);
    }
}

希尔排序

template <typename T>
void shell_sort(vector<T> &vec){
    for(int gap = vec.size()/2; gap > 0; gap /= 2){
        for(int i = gap; i < vec.size(); ++i){
            T tmp = vec[i];
            int j = i;
            for( ; j >= gap && vec[j-gap] > tmp; j -= gap)
                vec[j] = std::move(vec[j-gap]);
            vec[j] = std::move(tmp);
        }
    }
}

插入排序

template <typename T>
void insertion_sort(vector<T> &vec){
    for (int i = 1; i < vec.size(); ++i) {
        T tmp = std::move(vec[i]);

        int j;
        for(j = i; j > 0 && tmp < vec[j-1]; --j)
            vec[j] = std::move(vec[j-1]);
        vec[j] = std::move(tmp);
    }
}

冒泡排序

template <typename T>
void bubble_sort(vector<T> &vec){
    int last_unsorted_index = vec.size()-1;
    int swap_index = -1;
    bool is_swap = true;
    while (is_swap){
        is_swap = false;
        for (int i = 0; i < last_unsorted_index; ++i) {
            if(vec[i] > vec[i+1]) {
                std::swap(vec[i], vec[i + 1]);
                is_swap = true;
                swap_index = i;
            }
        }
        last_unsorted_index = swap_index;
    }
}

选择排序

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