排序算法

 冒泡排序、选择排序、插入排序的算法复杂度都是O(N*N)，在ubuntu16.04下，CPU为i7-2640m，g++版本为5.4.0，实际排序十万个不重复随机数的结果显示，冒泡排序运行时间71.2s，选择排序运行时间为41.2s，插入排序运行时间为39.8s，可见插入排序的效率更好一些。

实际上插入排序可以不用swap函数，利用类似堆排序的技巧，可以得到更进一步的优化，经过验证，优化后的插入排序的运行时间缩短到23.3秒。另外，如果序列已经预先排序，那三种O(N*N)算法只有插入排序会将复杂度降到O(N)，因为第一次比较之后break语句就将内部循环中断，相当于只进行了一次外部循环。

Shell排序的时间复杂度为次O(N*N)，实际测得比堆排序时间略长。

另外堆排序的运行时间为0.036秒，可见O(N*logN)复杂度对运行时间的巨大提升。

注意算法的边界条件的选取。

 

#include <iostream>
#include <algorithm>
#include <vector>
#include <iterator>  
#include <ctime>     
using namespace std;
//冒泡排序
template<typename T>
void sort_mp(vector<T>& items)
{
    for(int i = 0; i < items.size() - 1 && items[i] < items[i + 1]; ++i){
        if(i == items.size() - 2)
            return;
    }
    for(int i = items.size() - 1; i > 0; --i){
        for(int j = 0; j < i; ++j){
            if(items[j] > items[j + 1])
                swap(items[j], items[j + 1]);
        }
    }
}
//插入排序
template<typename T>
void sort_cr(vector<T>& items)
{
    for(int i = 1; i < items.size(); ++i){
        T tmp = items[i];
        for(int j = i; j > 0; --j){
            if(items[j - 1] > tmp)
                swap(items[j], items[j - 1]);
            else
                break;
        }
    }
}
//插入排序改进版，用于快排
template<typename T>
void sort_cr_pro(vector<T>& items, int begin, int end)
{
    for(int i = begin + 1; i <= end; ++i){
        T tmp = items[i];
        int j = i;
        for(; j > begin; --j){
            if(items[j - 1] > tmp)
                items[j] = items[j - 1];
            else
                break;
        }
        items[j] = tmp;
    }
}
//选择排序
template<typename T>
void sort_xz(vector<T>& items)
{
    for(int i = 0; i < items.size() - 1 && items[i] < items[i + 1]; ++i){
        if(i == items.size() - 2)
            return;
    }
    for(int i = 0; i < items.size() - 1; ++i){
        int min_index = i + 1;
        for(int j = i + 1; j < items.size(); ++j){
            if(items[min_index] > items[j])
                min_index = j;
        }
        if(items[min_index] < items[i])
            swap(items[min_index], items[i]);
    }
}
//希尔排序
template<typename T>
void sort_shell(vector<T>& items)
{
    int increment = items.size() / 2;
    while(increment > 0){
        for(int i = increment; i < items.size(); ++i){
            T tmp = items[i];
            int j = i;
            for(; j >= increment; j -= increment){
                if(items[j - increment] > tmp)
                    items[j] = items[j - increment];
                else
                    break;
            }
            items[j] = tmp;
        }
        increment /= 2;
    }
}

//堆排序1
template <typename T>
void itemDown1(vector<T>& array, int hole, int currentSize)
{
    T tmp = array[hole];
    int child = 0;
    for(; hole * 2 <= currentSize; hole = child){
        child = hole * 2;
        if(child != currentSize && array[child] < array[child + 1])
            child++;
        if(array[child] > tmp)
            array[hole] = array[child];
        else
            break;
    }
    array[hole] = tmp;
}
template <typename T>
void sort_heap1(vector<T>& items)
{
    int currentSize = items.size() - 1;
    for(int i = currentSize / 2; i >= 1; --i)
        itemDown1(items, i, currentSize);
    while(currentSize > 1){
        swap(items[currentSize--], items[1]);
        itemDown1(items, 1, currentSize);
    }
    T tmp = items[0];
    int j = 0;
    for(j = 0; j < items.size(); ++j){
        if(items[j + 1] < tmp)
            items[j] = items[j + 1];
        else
            break;
    }
    items[j] = tmp;
}

//堆排序2
template <typename T>
void itemDown2(vector<T>& array, int hole, int currentSize)
{
    T tmp = array[hole];
    int child;
    for(; hole * 2 + 1 < currentSize; hole = child){
        child = hole * 2 + 1;
        if(child != currentSize - 1 && array[child] < array[child + 1])
            ++child;
        if(array[child] > tmp)
            array[hole] = array[child];
        else
            break;
    }
    array[hole] = tmp;
}
template <typename T>
void sort_heap2(vector<T>& items)
{
    int currentSize = items.size();
    for(int i = items.size() / 2 - 1; i >= 0; --i)
        itemDown2(items, i, items.size());
    while(--currentSize > 0){
        swap(items[0], items[currentSize]);
        itemDown2(items, 0, currentSize);
    }
}
//归并排序
template <typename T>
void merge_(vector<T>& items, vector<T>& tmp, int lbegin, int rbegin,  int rend)
{
    int lend = rbegin - 1;
    int tmp_index = lbegin;
    int temp_begin = lbegin;
    while(lbegin <= lend && rbegin <= rend){
        if(items[lbegin] < items[rbegin])
            tmp[tmp_index++] = items[lbegin++];
        else
            tmp[tmp_index++] = items[rbegin++];
    }
    while(lbegin <= lend)
        tmp[tmp_index++] = items[lbegin++];
    while(rbegin <= rend)
        tmp[tmp_index++] = items[rbegin++];
    while(rend >= temp_begin){
        items[rend] = tmp[rend];
        --rend;
    }
}
template <typename T>
void sort_merge_Rec_(vector<T>& items, vector<T>& tmp, int begin, int end)
{
    if(begin < end){
        int middle = (begin + end) / 2;
        sort_merge_Rec_(items, tmp, begin, middle);
        sort_merge_Rec_(items, tmp, middle + 1, end);
        merge_(items, tmp, begin, middle + 1, end);
    }
}
template <typename T>
void sort_merge_Rec(vector<T>& items)
{
    vector<T> tmp(items.size());
    sort_merge_Rec_(items, tmp, 0, items.size() - 1);
}
//非递归归并排序   
template <typename T>
void sort_merge_NonRec_(vector<T>& items, vector<T>& tmp)
{
    int step = 2;
    while(step / 2 < items.size()){
        int i = 0;
        for(; i + step - 1 < items.size(); i += step){
            merge_(items, tmp, i, i + step / 2, i + step - 1);
        }
        if(i + step / 2 < items.size()){
            merge_(items, tmp, i, i + step / 2, items.size() - 1);
        }
        step *= 2;
    }
}
template <typename T>
void sort_merge_NonRec(vector<T>& items)
{
    vector<T> tmp(items.size());
    sort_merge_NonRec_(items, tmp);
}
//快排
template <typename T>
const T& get_pivot(vector<T>& items, int begin, int end)
{
    int middle = (begin + end) / 2;
    if(items[begin] > items[middle])
        swap(items[begin], items[middle]);
    if(items[begin] > items[end])
        swap(items[begin], items[end]);  
    if(items[middle] > items[end])
        swap(items[middle], items[end]);
    swap(items[middle], items[end - 1]);
    return items[end - 1];
}
template <typename T>
void sort_quick(vector<T>& items, int begin, int end)
{
    //可以在数组长度小于一定值时候采用插入排序改进，减少递归次数
    if(end - begin >= 3){
        T pivot = get_pivot(items, begin, end);
        int i = begin, j = end - 1;
        while(true){
            while(items[++i] < pivot){}
            while(items[--j] > pivot){}
            if(i < j)
                swap(items[i], items[j]);
            else
                break;
        }
        swap(items[i], items[end - 1]);
        sort_quick(items, begin, i - 1);
        sort_quick(items, i + 1, end);
    }
    else
        sort_cr_pro(items, begin, end);
}
template <typename T>
void sort_quick(vector<T>& items)
{
    sort_quick(items, 0, items.size() - 1);
}

template <typename T>
void sort_quick_(vector<T>& items, int begin, int end)
{
    /*递归过深可能导致栈溢出，可在数组小于一定长度时候
    由插入排序完成，数组长度长于一定长度改为快排
    */
    if(end - begin >= 1){
        T pivot = items[begin];
        int i = begin, j = end + 1;
        //如果此处为i<j，那么需要在while循环外判断items[j], items[begin]大小
        while(true){
            //此if用来处理有多个相同元素的排序，防止无限循环
            //if(i < j && items[i] == pivot && items[j] == pivot)
             //   --j;
            //此处对i的上限进行限制，否则i可能超出数组长度
            while(i < end && items[++i] < pivot ){}
            while(items[--j] > pivot){}
            if(i < j)
                swap(items[i], items[j]);
            else
                break;
        }
        /*if(items[j] < items[begin])， 前面循环为true，
        这里不再需要，因为j可达到begin处
        */
            swap(items[j], items[begin]);
        sort_quick_(items, begin, j - 1);
        sort_quick_(items, j + 1, end);
    }
}
template <typename T>
void sort_quick_(vector<T>& items)
{
    sort_quick_(items, 0, items.size() - 1);
}
int main()
{
    typedef ostream_iterator<int> OstreamItr;
    clock_t start,finish;
    vector<int> temp;
    for(int i = 0; i < 100; ++i)
        temp.push_back(i + 1);
    for(int i = 0; i < 1000; ++i)
        temp.push_back(i + 1);
    random_shuffle(temp.begin(), temp.end());
    vector<int> yj(temp.begin(), temp.begin() + 100);
    //sort(yj.begin(), yj.end());

    
    //copy(yj.begin(), yj.end(), OstreamItr(cout, " "));
    //cout << endl;
    
    start = clock();
    //sort(yj.begin(), yj.end());
    sort_quick(yj);
    finish = clock();
    cout << (double)(finish - start) / CLOCKS_PER_SEC << " s" << endl;
    copy(yj.begin(), yj.begin() + 20, OstreamItr(cout, " "));
    cout << endl;
    return 0;
}