八大排序算法总览

八大排序算法：

插入排序：
（1）直接插入排序：稳定排序，时间复杂度O(n^2)；
（2）希尔排序：直接插入排序的优化，非稳定排序，时间复杂度O(n^1/3);
选择排序：
（1）简单选择排序：非稳定排序，时间复杂度O（n^2)
（2）堆排序：非稳定排序，时间复杂度O(nlogn),用于topK问题
交换排序：
（1）冒泡排序：稳定排序，时间复杂度O(n^2)
（2）快速排序：非稳定排序，时间复杂度平均为O(nlogn),使用递归需要栈空间
归并排序：稳定排序，时间复杂度O(nlogn),分治的思想，使用递归需要栈空间，需要辅助空间
基数排序：稳定排序，时间复杂度O(d(n+k))

c++代码如下：

#include<iostream>
#include<vector>
#include<stdlib.h>
#include<string.h>
#include<list>
using namespace std;
class Sort
{
 public:
    Sort(int data);
    void srand();
    void show();
    void Insert();      //插入排序 稳定
    void Bubble();      //冒泡排序 稳定
    void Shell();       //希尔排序  不稳定
    void Selection();   //简单选择排序  不稳定
    void Quick(int L,int R);        //快速排序，不稳定
    void Merge(int L,int R);    //归并排序，稳定
    void Heap();                //堆排序 不稳定
    void Radix();
 private:
    int My_quick(int L,int R);
    void My_merge(int L,int R,int mid);
    void adjust_heap(int i);
    void clear_buttom(list<int> T[]);
    inline void Myswap(int *L,int *R)
    {
        int T=*L;
        *L=*R;
        *R=T;
    }
    inline int maxbit()
    {
        int ret=0;
        int bit=1;
        for(int i=0;i<size;i++)
        {
            while(buf[i]> bit)
            {
                bit*=10;
                ++ret;
            }
        }
        return ret;
    }

 private:
    vector<int> buf;
    int size;
};

void Sort::srand()
{
    cout<<"\n"<<"srand:"<<endl;
    buf.clear();
    for(int i=0;i<size;i++)
    {
        buf.push_back(rand()%size );
    }
    size=buf.size();
    show();
}

Sort::Sort(int data):size(data)
{
    srand();
}

void Sort::show()
{
    for(int i=0;i<buf.size();++i)
    {
        cout<<buf[i]<<" ";
    }
    cout<<endl;
}

void Sort::Insert()
{
    cout<<"insert sort: "<<endl;
    if(size<=1)return ;
    for(int i=1;i<size;++i)
    {
        int T=buf[i];   //给buf[i]找位置
        int j=i-1;
        for(j;j>=0;--j)
        {
            if(buf[j]<=T)
                break;
            buf[j+1]=buf[j];
            buf[j]=T;
        }
    }
}

void Sort::Bubble()
{
    cout<<"冒泡排序:"<<endl;
    if(!size)return ;
    for(int i=1;i<size;++i)       //冒泡次数,10个元素冒泡9个即可
    {
        for(int j=0;j<size-i;++j)//冒一个泡，最值浮出
        {
            if( buf[j] > buf[j+1] )
            {
                int d=buf[j];
                buf[j]=buf[j+1];
                buf[j+1]=d;
            }
        }
    }
}

void Sort::Shell()//不稳定排序
{
    cout<<"希尔排序: "<<endl;
    int step=size/2;
    while(step>=1)//step==1 直接插入排序
    {   
        //当前步长的直接插入排序
        for(int i=step;i<size;++i)
        {
            int T=buf[i];
            int j=i;
            for( j=i; j-step>=0 ;j-=step)   //buf overflow
            {
                if(T >buf[j-step])
                    break;
                buf[j]=buf[j-step];
                buf[j-step]=T;
            }           
        }
        step/=2;
    }
}

void Sort::Selection()
{
    for(int i=size-1;i>=0 ;--i)
    {
        int index=0;
        for(int j=0;j<=i;j++)
        {
            if( buf[j]>buf[index] )
            {
                index=j;
            }
            int tmp=buf[i];
            buf[i]=buf[index];
            buf[index]=tmp;
        }
    }
}

void Sort::Quick(int L,int R)
{
    if(L>=R)
        return ;
    int ret=My_quick(L,R);
    Quick(L,ret-1);
    Quick(ret+1,R);
}

int Sort::My_quick(int L,int R)
{
    while (L<R)
    {
        while(L<R && buf[L]<=buf[R]) --R;       //不带等于号，重复数字时，一直交换不会退出while
        Myswap(&buf[L],&buf[R]);
        while(L<R && buf[L]<=buf[R]) ++L;
        Myswap(&buf[L],&buf[R]);
    }
    return L;
}

void Sort::Merge(int L,int R)
{
    if(L>=R)
        return ;
    int mid=(R+L)/2;
    Merge(L,mid);
    Merge(mid+1,R);
    My_merge(L,R,mid);
}

void Sort::My_merge(int L,int R,int mid)
{
    if(L==R)
        return;
    int s[R-L+1];
    memset(s,0,sizeof(s));
    int t1=L,t2=mid+1,k=0;
    while(t1<=mid && t2<=R )
    { 
        if(buf[t1]<=buf[t2])
        {
            s[k]=buf[t1];
            k++;
            t1++;
        }
        else 
        {
            s[k]=buf[t2];
            k++;
            t2++;
        }
    }
    while(t2<=R)
    {
        s[k]=buf[t2];
        t2++;
        k++;      
    }
    while(t1<=mid)
    {
        s[k]=buf[t1];
        t1++;
        k++;      
    } 
    memcpy(&buf[L],s,sizeof(s));
}

void Sort::Heap()
{
    cout<<"堆排序："<<endl;
    for(int i=size/2-1;i>=0;--i) //创建大顶堆
    {
        adjust_heap(i);
    }  
    //下沉根节点（交换首尾），并调整成为大根堆
    for(int j=size-1;j>0;--j)
    {
        int T=buf[0];
        buf[0]=buf[j];
        buf[j]=T;
        size--;
        adjust_heap(0); //i为待调整节点
    }
}

void Sort::adjust_heap(int i)
{
    int rec=buf[i];
    for(int k=2*i+1;k<size;k=k*2+1) 
    {
        if(k+1<size && buf[k+1]>buf[k] ) ++k;
        if(buf[k]> rec)
        {
            buf[i]=buf[k];
            i=k;
        }
        else break;
    }
    buf[i]=rec;
}

void Sort::Radix()
{
    cout<<"基数排序："<<endl;
    int ret=maxbit();
    list<int> radix[10];
    size_t ratio=1; 
    for(int i=1;i <= ret;i++)   //要进行ret次分发归并
    {
        clear_buttom(radix);
        int rec=0;
        //分发处理
        int j=0;
        for(    ;j<size;j++)
        {
            rec=(buf[j]/ratio)%10;
            radix[rec].push_back(buf[j]);
        }
        ratio*=10;
        //收集处理
        j=0;
        for(int k=0;k<10;k++)
        {
            if(radix[k].size()==0)
            continue;
            for(auto x: radix[k])
            {
                buf[j]=x;
                ++j;
            }
        }
    }   
}

void Sort::clear_buttom(list<int> T[] )
{
    for(int i=0;i<10;++i)
    {
        T[i].clear();
    }
} 

int main()
{
    Sort s(13);
    // s.Insert();
    // s.show();
    
    // s.srand();
    // s.Bubble();
    // s.show();
    
    // s.srand();
    // s.Shell();
    // s.show();
    
    // s.srand();
    // s.Selection();
    // s.show();
    
    // s.srand();
    // cout<<"快速排序："<<endl;
    // s.Quick(0,12);
    // s.show();
    
    // s.srand();
    // cout<<"归并排序:"<<endl;
    // s.Merge(0,12);
    // s.show();
    
    // s.srand();
    // s.Heap();
    // s.show();
    
    s.srand();
    s.Radix();
    s.show();
    return 0;
}

结语：

如有错误欢迎指正。