排序

排序法	平均时间	最差情形	稳定度	额外空间
冒泡	O(n2)	O(n2)	稳定	O(1)
交换	O(n2)	O(n2)	不稳定	O(1)
选择	O(n2)	O(n2)	不稳定	O(1)
插入	O(n2)	O(n2)	稳定	O(1)
基数	O(logRB)	O(logRB)	稳定	O(n)
Shell	O(nlogn)	O(ns) 1<s<2	不稳定	O(1)
快速	O(nlogn)	O(n2)	不稳定	O(nlogn)
归并	O(nlogn)	O(nlogn)	稳定	O(1)
堆	O(nlogn)	O(nlogn)	不稳定	O(1)

插入排序：

   

#include<stdio.h>
//╡ЕхКеепР
template<class T1 ,class T2>
void Isort(T1 *arg , T2 len){

     T2 i,j;
   for(i=1; i<len ; i++){
      int val = arg[i];
      for( j= i-1 ; j>=0&&val<arg[j]; j--)
             arg[j+1]=arg[j];
       arg[j+1]=val;
   }
}
/*
template<class T1 ,class T2 ,size_t size>
void Isort(T1 (&arg)[size] , T2 len){

     T2 i,j;
   for(i=1; i<len ; i++){
      int val = arg[i];
      for( j= i-1 ; j>=0&&val<arg[j]; j--)
             arg[j+1]=arg[j];
       arg[j+1]=val;
   }
}
*/

冒泡排序：

  

void mPaoSort(int *arg , int len){
   int i,j;
   bool tag;
   for(i=0;i<len ;i++){
     for(j=i+1 , tag= false ;j<len ;j++){
        if(arg[i]>arg[j]){
            arg[i]^=arg[j];
            arg[j]^=arg[i];
            arg[i]^=arg[j];
            tag=true;
        }
     }
     if(!tag) break;
   }
}

归并排序：

void Merge(int *A ,int ps ,int mid , int len){
      int i=ps,j=mid,cnt=0;
      int C[len-ps+1];
      while(i<mid&&j<len ){
       if(A[i]>A[j]) C[cnt++]=A[j++];
       else C[cnt++]=A[i++];
      }
      while(i<mid) C[cnt++]=A[i++];
      while(j<len) C[cnt++]=A[j++];
      for(i=ps; i<len ;i++)
            A[i]=C[i-ps];
}



//递归版
void Msort(int *arg ,int ps, int len){

    if(ps+1<len) {
    int mid = ps+((len-ps)>>1L);
    Msort(arg ,ps ,mid);
    Msort(arg, mid,len);
    Merge(arg ,ps,mid, len);
}
}
//非递归版
void Msort_(int *arg , int ps , int len){

     int s,t=1;
     while(ps+t<=len){
         s=t;
         t=2*s;
         int pos=ps;
       while(pos+t<=len){
         Merge(arg,pos,pos+s,pos+t);
         pos+=t;  //移动
       }
       if(pos+s<len)
           Merge(arg,pos,pos+s,len);
     }
     if(ps+s<len)
       Merge(arg,ps,ps+s,len);

}

计数排序：

  

//╪фйЩеепР
void JSort(int *arg , int len){
    int ans[10]={0} ,i,j=0;
    for(i=0; i<len ;i++)
        ans[arg[i]]++;
    for(j=i=0;i<10 ;i++)
      while(ans[i]--)
         arg[j++]=i;
}

桶排序：

//桶排序
#include<iostream>
#include<string.h>

typedef struct node{

   int val ;
   struct node * next;
   void init(){
      val=0;
      next=NULL;
   }
}Node;

void BSort(int *arg , int len , int blen ){

    int i;
    Node* Barry = (Node *)malloc(blen*sizeof(Node));  //定义一个二维数组
    for( i=0;i<blen ;i++)
        Barry[i].init();
        Node *head =NULL;
    for( i=0;i<len ;i++){
      Node *p = (Node *)malloc(sizeof(Node));
        p->val=arg[i];
        p->next=NULL;
        int sp = arg[i]/10;
        head =&Barry[sp];
        if(!head->val){
            //为空，就直接将其加载到后面即可
            head->next = p;
            head->val=head->val+1;  //统计个数
        }else{
         //如果不相等,选择插入排序
           Node *tm=head->next ,*cur =head;
           while(tm!=NULL&&tm->val<arg[i]){
                 cur =tm;
                 tm=tm->next;
           }
           cur->next=p ;
           p->next = tm;
           head->val=head->val+1;
        }
    }
    for(int i=0; i<blen ;i++){
        Node *p;
        if(Barry[i].val){
          p = Barry[i].next;
         while(p){
            printf("%d ",p->val);
            p=p->next;
         }
         puts("");
        }
    }
}

int main1(int argc , char* argv[] ){
   int ss[]={3,4,5,61,12,8,9,20,22,45,87};

   BSort(ss ,sizeof(ss)/sizeof(int), 10);
   return 0;
}

选择排序：

//选择排序
void  Ssort(int *arg ,int len){
  for(int i=0;i<len ;i++){
     int mx=i;
    for(int j=i+1; j<len ;j++){
        if(arg[mx]<arg[j])mx=j;
    }
     if(i!=mx){
        arg[mx]^=arg[i];
        arg[i]^=arg[mx];
        arg[mx]^=arg[i];
     }
  }
}

快速排序：

//快速排序
void qsort(int *arg ,int ps ,int len){

  int i,j,val=arg[ps];
  if(ps<len){
    i=ps,j=len;
    while(i!=j){
      while(i<j&&arg[j]>=val) j--;
      if(i<j) arg[i] = arg[j];
      while(i<j&&arg[i]<=val) i++;
      if(i<j)arg[j]=arg[i];
    }
  arg[i]=val;
  qsort(arg,ps ,i-1);
  qsort(arg,i+1,len);
 }
}

堆排序：

//堆排序
void MaxHeap(int *arg ,int ps ,int len){
   //构建一个堆
 int cl = 2*ps , cr = 2*ps+1;

 if(ps<=len/2){
   int mx = ps;  //父节点
   if(cl<len&&arg[mx]<arg[cl])   mx = cl;
   if(cr<len&&arg[mx]<arg[cr])   mx = cr;
   if(mx!=ps){
      arg[mx]^=arg[ps];
      arg[ps]^=arg[mx];
      arg[mx]^=arg[ps];
      MaxHeap(arg,mx,len);  //数据有改动，需要重新对改动的地方进行维护
   }
  }
}

//建立新堆
void Build(int *arg , int len){
   for(int i=len/2 ; i>=1 ; i--){
        MaxHeap(arg,i,len);
   }
}

//堆排序Hsort
void Hsort(int *arg , int len){
       Build(arg,len);  //初始化
      // (o(n))
       for(int i=len ; i>1 ; i--){
        arg[1]^=arg[i];
        arg[i]^=arg[1];
        arg[1]^=arg[i];
        MaxHeap(arg,1,i);
     }
}

基数排序：

//基数排序
typedef struct bas{
   int val;
   struct bas *next;
   void init(){
     val=0;
     next=NULL;
  }
}Bas;
void Basort(int *arg  ,int len){
  //对于数字在0-9
    Bas *Barr[10];  //0-9
    for(int i=0;i<10 ; i++){
      Barr[i] = (Bas *)malloc(sizeof(Bas));
      Barr[i]->init();
    }
  bool tag=false;
  int mod =1;
   while(1){
    tag=false;
        for(int i=0;i<10 ; i++)
            Barr[i]->init();
     for(int i=0;i<len ; i++){
        Bas *p  = (Bas *)malloc(sizeof(Bas));
        p->val=arg[i];
        p->next=NULL;
        int hig =arg[i]/mod;
        int dex = hig%10;
        if(hig) tag=true;  //只要有一位不为0，就继续
        Bas *pb=Barr[dex];
        while(pb->next)
            pb = pb->next;
           pb->next = p;
    }
    //将值全部放置到arg中
    int cnt=0;
    for(int i=0;i<10 ; i++){
         Bas *pb = Barr[i]->next,*tm;
         while(pb){
            arg[cnt++]=pb->val;
            tm=pb;
            pb=pb->next;
            free(tm);
         }
    }
    if(!tag) return ;
    mod*=10;
  }
}

int  main(){
 int sss[]={100,123,45,67,123,1,4,5,10};
 Basort(sss,sizeof(sss)/sizeof(int));
 print(sss,sizeof(sss)/sizeof(int));
 return 0;
}