经典排序算法合集——C++模板实现

数据结构内部排序C++模板实现如下：

#include <iostream>
#include <vector>
#include <random>
#include <ctime>
#include <cstdlib>

using namespace std;
/*直接插入排序
 *将第i个记录插入到前面i-1个已经排好序的记录中，是最基本的插入排序方法
 * 1、使用监视哨保存待插入的记录
 * 2、从后往前查找应插入到位置
 * 3、查找与移动在同一循环中完成
 */
template<typename T>
void Insert_Sort(vector<T> &qs)
{
    unsigned int i=0;
    int j=0;
    T temp;
    for(i=1;i<qs.size();i++)
    {
        temp=qs[i],j=i-1;
        while(temp<qs[j])
        {
            qs[j+1]=qs[j];
            j=j-1;
            if(-1==j)
            {
                break;
            }
        }
        qs[j+1]=temp;
    }
}
/*折半插入排序
 * 用折半查找方法确定应插入位置
 */
template<typename T>
void Binary_Sort(vector<T> &qs)
{
    unsigned int i=0;
    int j=0;
    int low=0;
    int high=0;
    int mid=0;
    T temp;
    for(i=1;i<qs.size();i++)
    {
        temp=qs[i];
        low=0;
        high=i-1;
        while(low<=high)
        {
            mid=(low+high)/2;
            if(temp<qs[mid])
            {
                high=mid-1;
            }
            else
            {
                low=mid+1;
            }
        }
        for(j=i-1;j>=low;j--)
        {
            qs[j+1]=qs[j];
        }
        qs[low]=temp;
    }
}
/*希尔排序
 * 又称缩小增量排序法，是一种基于插入思想的排序方法。利用了直接循环排序的最佳性质。
 * 将待排序的关键字序列分成若干个较小的子序列，对子序列进行直接插入排序，
 * 使整个待排序序列排好。
 */
template<typename T>
void Shell_Sort(vector<T> &qs,vector<int> delta)
{
    int dta;
    unsigned int index=0;
    unsigned int i=0;
    int j=0;
    T temp;
    for(index=0;index<delta.size();index++)
    {
        dta=delta[index];
        for(i=0+dta;i<qs.size();i++)
        {
            if(qs[i]<qs[i-dta])
            {
                temp=qs[i];
                for(j=i-dta;(j>-1)&&(temp<qs[j]);j-=dta)
                {
                    qs[j+dta]=qs[j];
                }
                qs[j+dta]=temp;
            }
        }
    }
}
/*冒泡排序
 * 简单的交换类排序方法，通过相邻的数据元素的交换，逐步将待排序
 * 序列变成有序序列的过程。
 */
template<typename T>
void BubbleSort(vector<T> &qs)
{
    int i=0;
    int j=0;
    T temp=0;
    bool change=true;
    int length=qs.size();
    for(i=1;(i<length)&&change;i++)
    {
        change=false;
        for(j=0;j<length-i;j++)
        {
            if(qs[j]>qs[j+1])
            {
                temp=qs[j];
                qs[j]=qs[j+1];
                qs[j+1]=temp;

                change=true;
            }
        }
    }
}
/*快速排序
 * 通过两个不相邻元素的交换，消除待排序记录中的多个逆序
 */
template<typename T>
void Quick_Sort(vector<T> &qs,int left,int right)
{
    T temp;
    int pos=0;
    int low=left;
    int high=right;
    if(left<right)
    {
        temp=qs[left];
        while(low<high)
        {
            while((low<high)&&(qs[high]>=temp))
            {
                high--;
            }
            if(low<high)
            {
                qs[low]=qs[high];
                low++;
            }
            while((low<high)&&(qs[low]<temp))
            {
                low++;
            }
            if(low<high)
            {
                qs[high]=qs[low];
                high--;
            }
        }
        qs[low]=temp;
        pos=low;
        Quick_Sort(qs,left,pos-1);
        Quick_Sort(qs,pos+1,right);
    }
}
/*简单选择排序
 * 每一趟在n-i个记录中选取关键字最小的记录作为有序序列中第i个记录。
 */
template<typename T>
void select_Sort(vector<T> &qs)
{
    int i=0;
    int j=0;
    int k=0;
    T temp;
    int length=qs.size();
    for(i=0;i<length-1;i++)
    {
        k=i;
        for(j=i+1;j<length;j++)
        {
            if(qs[j]<qs[k])
            {
                k=j;
            }
        }
        if(k!=i)
        {
            temp=qs[i];
            qs[i]=qs[k];
            qs[k]=temp;
        }
    }
}
/*堆排序 大根堆
 * 在排序过程中，将向量中存储的数据看成一棵完全二叉树，利用完全二叉树中
 * 双亲结点和孩子结点之间的内在关系来选择关键字最小的记录，即将待排序记录仍采用向量数组方式存储，
 * 并非采用树的存储结构，而仅仅采用完全二叉树的顺序结构的特征进行分析而已。
 */
template<typename T>
void Heap_Sort(vector<T> &qs)
{
    int i=0;
    T temp;
    int n=qs.size();
    bool finished=false;
    T t;
    T x;
    int w=0;
    int j=0;
    //建初堆
    for(i=(n-1)/2-1;i>=0;i--)
    {
        //sift(qs,i,n)
        t=qs[i];
        x=qs[i];
        w=i;
        j=2*w+1;
        finished=false;
        while((j<=n-1)&&(!finished))
        {
            if((j<n-1)&&(qs[j]<qs[j+1]))
            {
                j++;
            }
            if(x>qs[j])
            {
                finished=true;
            }
            else
            {
                qs[w]=qs[j];
                w=j;
                j=2*w+1;
            }
        }
        qs[w]=t;
    }

    for(i=n-1;i>=1;i--)
    {
        temp=qs[0];
        qs[0]=qs[i];
        qs[i]=temp;
        //建初堆 sift(qs,0,i-1)
        t=qs[0];
        x=qs[0];
        w=0;
        j=2*w+1;
        finished=false;
        while((j<=i-1)&&(!finished))
        {
            if((j<i-1)&&(qs[j]<qs[j+1]))
            {
                j++;
            }
            if(x>=qs[j])
            {
                finished=true;
            }
            else
            {
                qs[w]=qs[j];
                w=j;
                j=2*w+1;
            }
        }
        qs[w]=t;
    }
}
/*归并排序
 *将两个或两个以上的有序表合并成一个新的有序表
 *2路归并排序法的基本操作是将待排序列中相邻的两个有序子序列合并成一个有序序列
 */
template<typename T>
void MergeSort(vector<T> &qs1,int low,int high,vector<T> &qs)
{
    int mid=0;
    int i=0;
    int j=0;
    int k=0;
    int index=0;
    if(low>=high)
    {

    }
    else
    {
        mid=(low+high)/2;
        MergeSort(qs1,low,mid,qs);
        MergeSort(qs1,mid+1,high,qs);
        i=low;
        j=mid+1;
        k=low;
        while((i<=mid)&&(j<=high))
        {
            if(qs1[i]<=qs1[j])
            {
                qs[k]=qs1[i];
                i++;
            }
            else
            {
                qs[k]=qs1[j];
                j++;
            }
            k++;
        }
        while(i<=mid)
        {
            qs[k]=qs1[i];
            k++;
            i++;
        }
        while(j<=high)
        {
            qs[k]=qs1[j];
            k++;
            j++;
        }
        for(index=low;index<=high;index++)
        {
            qs1[index]=qs[index];
        }
    }
}


int main()
{
    srand((int)time(0));
    vector<int> data;
    vector<int> tdata;
    vector<int> delta;
    vector<int> tmp;
    int number=1;
    int i=0;
    for(number=1;number<=16;number++)
    {
        for(int i=0;i<number;i++)
        {
            data.push_back(rand()%10000);
        }
        cout<<number<<": "<<endl;
        cout<<"原始序列"<<endl;
        for(i=0;i<number;i++)
        {
            cout<<data[i]<<'\t';
        }

        cout<<endl<<endl;

        cout<<"直接插入排序"<<endl;
        tdata.resize(number);
        for(i=0;i<number;i++)
        {
            tdata[i]=data[i];
        }
        Insert_Sort(tdata);
        for(i=0;i<number;i++)
        {
            cout<<tdata[i]<<'\t';
        }

        cout<<endl<<endl;


        cout<<"折半插入排序"<<endl;
        tdata.resize(number);
        for(i=0;i<number;i++)
        {
            tdata[i]=data[i];
        }
        Binary_Sort(tdata);
        for(i=0;i<number;i++)
        {
            cout<<tdata[i]<<'\t';
        }

        cout<<endl<<endl;


        cout<<"希尔排序"<<endl;
        tdata.resize(number);
        for(i=0;i<number;i++)
        {
            tdata[i]=data[i];
        }
        for(i=0;i<=number/2;i+=2)
        {
            delta.push_back((i==0?1:i));
        }
        Shell_Sort(tdata,delta);
        for(i=0;i<number;i++)
        {
            cout<<tdata[i]<<'\t';
        }

        cout<<endl<<endl;


        cout<<"冒泡排序"<<endl;
        tdata.resize(number);
        for(i=0;i<number;i++)
        {
            tdata[i]=data[i];
        }
        BubbleSort(tdata);
        for(i=0;i<number;i++)
        {
            cout<<tdata[i]<<'\t';
        }

        cout<<endl<<endl;


        cout<<"快速排序"<<endl;
        tdata.resize(number);
        for(i=0;i<number;i++)
        {
            tdata[i]=data[i];
        }
        Quick_Sort(tdata,0,tdata.size()-1);
        for(i=0;i<number;i++)
        {
            cout<<tdata[i]<<'\t';
        }

        cout<<endl<<endl;


        cout<<"简单选择排序"<<endl;
        tdata.resize(number);
        for(i=0;i<number;i++)
        {
            tdata[i]=data[i];
        }
        select_Sort(tdata);
        for(i=0;i<number;i++)
        {
            cout<<tdata[i]<<'\t';
        }

        cout<<endl<<endl;


        cout<<"堆排序"<<endl;
        tdata.resize(number);
        for(i=0;i<number;i++)
        {
            tdata[i]=data[i];
        }
        Heap_Sort(tdata);
        for(i=0;i<number;i++)
        {
            cout<<tdata[i]<<'\t';
        }

        cout<<endl<<endl;


        cout<<"归并排序"<<endl;
        tdata.resize(number);
        for(i=0;i<number;i++)
        {
            tdata[i]=data[i];
        }
        tmp.resize(number);
        MergeSort(tdata,0,tdata.size()-1,tmp);
        for(i=0;i<number;i++)
        {
            cout<<tdata[i]<<'\t';
        }

        cout<<endl<<endl;

    }

    return 0;
}