C++常用的排序算法

说明

将C++中的一些常用的排序算法整合到一起。

程序

 enum orderLift{
        Ascending,        //升序
        Descending        //降序
        };
    enum orderNum{
        bubbl,            //冒泡排序法
        insert,           //插入排序法
        select,           //选择排序法
        shell,            //希尔排序法
        heap,             //堆排序法
        merge,            //并归排序法
        quick             //快速排序法
    };
    vector<int> Testlib::orderingNumber(vector<int> num, orderNum order, Testlib::orderLift lift) //数组，排序方式，升降序
{
    switch(order)
    {
    case bubbl:bubblsort(num);break;          //冒泡排序法
    case insert:insertsort(num);break;        //插入排序法
    case select: selectsort(num);break;       //选择排序法
    case shell:shellsort(num);break;          //希尔排序法
    case heap:heapsort(num);break;            //堆排序法
    case merge:mergesort(num);break;          //并归排序法
    case quick:quicksort(num);break;          //快速排序法
//    default:break;                            //默认不采用任何的排序方式
    }
    switch(lift)
    {
    case Ascending:break;                      //排序方法默认为升序的排序方法，不做任何操作
    case Descending:                           //逆序输出
        vector<int> num2(num.size());
        uint numsize=num.size();
        for(uint i=0;i<numsize;i++)
        {
            num2[numsize-1-i]=num[i];
        }
        num=num2;
        break;
    }
    return num;
}

void Testlib::bubblsort(vector<int> &arry) //冒泡排序法
{
    uint n = arry.size();
    for (uint i = 0; i < n; i++)
    {
        for (uint j = 0; j < n -1; j++)
        {
            if (arry[j] > arry[j+1])
            {
                swap(arry[j], arry[j+1]);
            }
        }

    }
}

void Testlib::insertsort(vector<int> &arry)
{
    uint n = arry.size();
        for (uint i = 1; i < n; i++)
        {
            int insert_num = arry[i];
            uint j;
            for (j = i ; j > 0; j--)
            {
                if (arry[j-1] > insert_num)
                    arry[j ] = arry[j-1];
                else
                    break;
            }
            arry[j] = insert_num;
        }
}


void Testlib::selectsort(vector<int>& arry)
{
    for (uint i = 0; i < arry.size() - 1; i ++)
    {
        uint swap_pos = i;
        for (uint j = i + 1; j < arry.size(); j++)
        {
            if (arry[swap_pos] > arry[j])
            {
                swap_pos = j;
            }
        }

        if (swap_pos != i)
        {
            swap(arry[swap_pos], arry[i]);
        }
    }
}

void Testlib::shellsort(vector<int>& arry)
{
    uint n = arry.size();
    for (int increment = n / 2; increment > 0; increment /= 2)
    {
        for (uint i =static_cast<uint>(increment); i < n; i++)
        {
            int insert_num = arry[i], j;
            for (j =static_cast<int>(i) - increment; j >= 0; j -= increment)
            {
                if (arry[static_cast<uint>(j)] > insert_num)
                    arry[static_cast<uint>(j+increment)] = arry[static_cast<uint>(j)];
                else
                    break;
            }
            arry[static_cast<uint>(j+increment)] = insert_num;
        }
    }
}
static void make_heap(vector<int>& a, uint size) //size的当前堆的大小，也就是数组的前size个数
{
    for (uint i = size - 1; i > 0; i--)
    {
        if (i % 2 && a[i] > a[(i - 1) / 2])//奇数
            swap(a[i], a[(i - 1) / 2]);
        else if (i % 2 == 0 && a[i] > a[(i - 2) / 2])//偶数
            swap(a[i], a[(i - 2) / 2]);
    }
}
void Testlib::heapsort(vector<int>& arry)
{
    uint n = arry.size();
    while (n)
    {
        make_heap(arry, n); //每次把新的最大元素移到堆顶，也就是a[0]
        n--;
        swap(arry[0], arry[n]); //然后把当前最大移动到后面来作为排好序的元素
    }
}
static vector<int> mergeHelper(vector<int> &a, uint left, uint right)
{
    if (left == right) return vector<int> (1, a[left]);
    uint mid = (right - left) / 2 + left;
    vector<int> l = mergeHelper(a, left, mid);
    vector<int> r = mergeHelper(a, mid + 1, right);
    //merge
    vector<int> ret;
    uint ll = 0, rr = 0;
    while (ll < l.size() && rr < r.size())
    {
        if (l[ll] <= r[rr])     ret.push_back(l[ll++]);
        else                    ret.push_back(r[rr++]);
    }
    while (ll < l.size()) ret.push_back(l[ll++]);
    while (rr < r.size()) ret.push_back(r[rr++]);
    return ret;
}

void Testlib::mergesort(vector<int>& arry)
{
    arry = mergeHelper(arry, 0, arry.size() - 1);
}
static void quicksortHelper(vector<int>& a, uint start, uint end)
{
    if (start >= end) return;
    uint l =start, r =end;
    int pivot = a[(end - start) / 2 + start];
    while (l <= r)
    {
        while (l <= r && a[r] > pivot)  r--;
        while (l <= r && a[l] < pivot)  l++;
        if (l <= r) swap(a[l++], a[r--]);
    }
    quicksortHelper(a, start, r);
    quicksortHelper(a, l, end);
}
void Testlib::quicksort(vector<int>& arry)
{
    quicksortHelper(arry, 0, arry.size() - 1);
}

最后

使用统一程序就可以实现多种排序算法的调用。