算法——排序算法个人总结

总结：
O(n^2) 冒泡/插入/选择
O(nlogn) 快速/归并/堆
O(n^1.3) Shell排序
O(n) 桶/基数(位数差别不大，先低位排序后高位排序)/箱子

数据为正序时，插入和冒泡最佳。
稳定排序： 冒泡/插入/基数/归并。
不稳定排序：选择/快速/shell/堆。
邻近交换的排序基本上是稳定的，存在远距离交换的是不稳定排序。

具体代码如下：

#include<algorithm>
/*  冒泡排序：相邻元素比较；n为数据长度*/
template<typename T>
void BubbleSort(T* r, int n)
{   T temp; bool empty;
    for(int i=0;i<n-1;i++)
    {   empty=false;
        for(int j=0;j<n-1-i;j++)
            if(r[j]>r[j+1])
            {temp=r[j];r[j]=r[j+1];r[j+1]=temp; empty=true;}
        if(!empty)
            return ;
    }
}
/*快速排序：左边比他小，右边比他大，递归实现；
定义的一个关键数据，可以省去数据交换操作
low=0,high=数据长度-1*/
template<typename T>
void QuickSort(T a[],int low,int high)
{   if(low >=high)
        return ;
    T elem = a[low];    int l = low, r = high;
    while(l < r)
    {   while(l < r && a[r] >= elem) r--;
        if (l < r){ a[l++] = a[r];  }
        while(l< r && a[l] <= elem) l++;
        if (l < r)  {   a[r--] = a[l];  }
    }
    a[r] = elem;
    QuickSort(a,low,r-1);
    QuickSort(a,r+1,high);
}
/*插入排序：数据向右移动，a[j+1]=a[j]
n为数据长度*/
template<typename T>
void InsertSort(T a[],int n)
{  int i,j; T elem;
    for (i=1;i<n ;++i)
    {   j = i- 1;   elem = a[i];
        while(j>=0 && elem < a[j] ) {   a[j+1] = a[j];    j--;  }
        a[j+1] = elem;
    }
}
/*希尔（shell）排序：分组进行插入排序(把插入排序1的改成d即可)
n为数据长度*/
template<typename T>
void ShellInsert(T arra[],int d,int n)
{  int i,j;  T elem;
    for ( i = d;i < n;i++)  //首个下标从d开始
    {   j = i - d;      elem = arra[i];                        
        while (j >= 0 && elem < arra[j])         
        {  arra[j+d] = arra[j];   j = j - d;  }           
        arra[j+d] = elem;             
    }
}
template<typename T>
void ShellSort(T arra[],int n)
{  int inc = n;    
    do  { inc = inc/2;        
        ShellInsert(arra,inc,n);    
    }   while (inc > 1);
}
/*选择排序：在未排序中找出最小的放在前面*/
template <typename T>
void SelectSort(T a[],int n)
{   T  elem;
    for (int i=0;i<n-1;i++)
    {   int elemNum = i;
        for (int j= i+1;j<n;j++)
            if (a[j] < a[elemNum])  
                elemNum = j;
        if (elemNum != i)
        {   elem = a[i];    a[i] = a[elemNum];  a[elemNum] = elem;}     
    }
}
/*归并排序：左边小取左边，左边++；右边小取右边，右边++*/
template<typename T>
void Merge(T arra[], int low, int mid, int high)
{   int k;   T *temp = new T[high-low+1]; 
    int begin1 = low, end1 = mid, begin2 = mid + 1, end2 = high;    
    for (k = 0; begin1 <= end1 && begin2 <= end2; ++k) 
    {   if(arra[begin1]<=arra[begin2])      temp[k] = arra[begin1++];
        else        temp[k] = arra[begin2++];   
    }   
    if(begin1 <= end1) 
        for(int p=begin1;p<=end1;p++)   temp[k++]=arra[p];
    if(begin2 <= end2) 
         for(int p=begin2;p<=end2;p++)   temp[k++]=arra[p];
    for(int s=left;s<=right;s++)      arra[s]=temp[s-left];
    delete []temp;
}
template<typename T>
void MergeSort(T arra[], unsigned int first, unsigned int last)
{   int mid = 0;
    if(first>=last) return;
    mid = (first+last)/2;   
    MergeSort(arra, first, mid);
    MergeSort(arra, mid+1,last);
    Merge(arra,first,mid,last);
}
//*堆排序*/
template <typename E>
void HeapDown( E a[],int pos,int len)
{   E temp=a[pos]; int k=pos;//插入排序的思想
      for(int i=2*k+1;i<len;i=2*i+1)//下标从0开始
      { if(i<len-1 && a[i]<a[i+1]) i++;
            if(a[i]>temp) {a[k]=a[i];k=i;}
            else break;
      }
      a[k]=temp;
}
template <typename E>
void HeapSort( E a[],int n)
{     for(int i=n/2;i>=0;i--) HeapDown(a,i,n);//建堆
      for(int j=n-1;j>=1;j--)
      {     swap(a[j],a[0]);
            HeapDown(a,0,j);
      }
}

---

add here 2016-07-28，程序猿闲来无事，重写了一份，比上面稍微简洁点

/******************
各种排序算法的源代码
*******************/
#include<iostream>
#include<algorithm>
using namespace  std;
void  swap( int & a, int & b){
    int temp=a;
    a=b;
    b=temp;
}
/*冒泡排序*/
void bubbleSort(int * a ,int n){
    for(int i=0;i<n-1;i++){
        bool f=false;
        for(int j=0;j<n-1-i;j++){
            if(a[j]>a[j+1]){
                swap(a[j],a[j+1]);
                f=true;
            }
        }
        if(f ==  false){
          return ;
        }
    }
}
/*快速排序, 模版类实现*/
template <class T>
void quickSort( T * a, int left ,int right){
    if(left>= right){   return ;    }
    int l=left,r=right;
    T temp=a[left];
    while(l < r){
        while( l<r  && a[r]> temp){ r--;}
        if(l< r){ a[l++]=a[r];}
        while(l<r &&  a[l]<temp){l++;}
        if(l<r){ a[r--]=a[l];}
    }
    a[r]=temp;
    quickSort(a,left,r-1);
    quickSort(a,r+1,right);
}
/*数组排序, 模版类实现。*/
template <class  T>
void  merge(T * a ,int left,int middle ,int right){
    if(left>middle || middle> right) return;
    T * pTemp=new T[right-left+1];
    int l=left,r=middle+1;
    int i=0;
    while(l<=middle &&  r<= right){
        if(a[l]<a[r]){
            pTemp[i++]=a[l++];
        }else{
            pTemp[i++]=a[r++];
        }
    } 
    while(l<=middle){
        pTemp[i++]=a[l++];
    }
    while(r<=right){
        pTemp[i++]=a[r++];
    }
    for(int i=0;i<(right-left+1);i++){
        a[left+i]=pTemp[i];
    }
    delete pTemp;
    return ;
}
/*归并排序, 模版类实现*/
template <class T>
void  mergeSort( T  * a ,int l,int r){
    if(l>=r) return ;
    int m=((r-l)>>1)+l;
    mergeSort(a,l,m);
    mergeSort(a,m+1,r);
    merge(a,l,m,r);
}
/*选择排序，模版类实现*/
template  <class T>
void selectSort(T * a,int n){
    for(int i=0;i<n-1;i++){
        int k=i;
        for(int j=i;j<n;j++){
            if(a[k]>a[j]){
                k=j;
            }
        }
        if(k != i){
            swap(a[k],a[i]);
        }
    }
}
/*插入排序，模版类实现*/
template <class T>
void  insertSort(T * a, int n){
    for(int i=1;i<n;i++){
        T temp=a[i];
        int j=i-1;
        while(j>=0 &&  a[j]>temp){ a[j+1]=a[j]; j--;}
        a[j+1]=temp;
    }
}
/*shell希尔排序,模版类实现,相当于从0开始步距为d的sort排序*/
template < class T>
void shellSort(T * a ,int n ,int d){
    for(int i=d;i<n;i+=d){
        T temp=a[i];
        int  j=i-d;
        while(j>=0 &&  a[j]>temp){a[j+d]=a[j];j-=d;}
        a[j+d]=temp;
    }
}
template < class T>
void  shell(T * a ,int n){
    if(n<=1) return ;
    int d=n>>1;
    while(d>=1){
        shellSort(a,n,d);
        d=d>>1;
    }
}
/*堆排序，模板类实现
asc排序，用到最大堆*/
template <class T>
void  heapDown(T * a , int n ,int nodePos){
    int p=nodePos;
    T temp=a[p];
    for(int k=2*nodePos+1;k<n;k=2*k+1){
        if(k+1<n &&  a[k+1]>a[k]){
            k++;
        }
        if(a[k]> temp){
            a[p]=a[k];p=k;
        }else{
            break;
        }
    }
    a[p]=temp;
}
template <class T>
void  heapSort(T a[] ,int n){
    for(int i=n/2;i>=0;i--){
        heapDown(a,n,i);
    }
    for(int i=n-1;i>=1;i--){
        swap(a[i],a[0]);
        heapDown(a,i,0);
    }
}
int  main(){
   cout<<"start"<<endl;
   int a[10]={5,4,2,1,3,9,8,6,0,7};
   //bubbleSort(a,10);
   //quickSort(a,0,9);
   //mergeSort(a,0,9);
   //selectSort(a,10);
   //insertSort(a,10);
   //shell(a,10);
   heapSort(a,10);
   for(int j=0;j<10;j++){
        cout<<a[j]<<"\t";
   }
   cout<<endl<<"end"<<endl;
   return  0;
}