常用排序算法总结

1.插入排序
平均时间复杂度O(n^2)，最优时间复杂度O(n)，最差时间复杂度O(n^2)，空间复杂度O(1)，稳定。

void insertionSort(int *A,int n){    for(int j=1;j<n;++j)    {        int key=A[j],i=j-1;        for(;i>=0&&A[i]>key;--i)A[i+1]=A[i];        A[i+1]=key;    }}

二分插入排序（折半插入排序）
稳定。

void binaryInsertionSort(int *A,int n){    for(int j=1;j<n;++j)    {        int key=A[j],left=0,right=j-1;        while(left<=right)        {            int mid=left+(right-left)/2;            if(A[mid]<key)left=mid+1;            else if(A[mid]>key)right=mid-1;            else            {                int i=mid+1;                for(;i<=j-1&&A[i]==key;++i);                left=i;                break;            }        }        for(int i=j-1;i>=left;--i)A[i+1]=A[i];        A[left]=key;    }}

希尔排序（缩小增量排序）
不稳定。

void shellSort(int *A,int n){    for(int inc=n/2;inc;inc/=2)    {        for(int j=inc;j<n;j+=inc)        {            int key=A[j],i=j-inc;            for(;i>=0&&A[i]>key;i-=inc)A[i+inc]=A[i];            A[i+inc]=key;        }    }}

2.归并排序
平均时间复杂度O(nlogn)，最优时间复杂度O(n)，最差时间复杂度O(nlogn)，空间复杂度O(n)，稳定。

void merge(int *A,int p,int q,int r){    int n1=q-p+1,n2=r-q;    int *L=new int[n1+1],*R=new int[n2+1];    for(int i=0;i<n1;++i)L[i]=A[p+i];    for(int i=0;i<n2;++i)R[i]=A[q+1+i];    L[n1]=R[n2]=INT_MAX;    int i=0,j=0;    for(int k=p;k<=r;++k)    {        if(L[i]<=R[j])A[k]=L[i++];        else A[k]=R[j++];    }    delete [] L,R;}void mergeSort(int *A,int p,int r){    if(p<r)    {        int q=p+(r-p)/2;        mergeSort(A,p,q);        mergeSort(A,q+1,r);        merge(A,p,q,r);    }}

3.堆排序
时间复杂度O(nlogn)，空间复杂度O(1)，不稳定。

void maxHeapify(int *A,int n,int i){    int l=2*i+1,r=l+1,largest=i;    if(l<n&&A[l]>A[i])largest=l;    if(r<n&&A[r]>A[largest])largest=r;    if(largest!=i)    {        swap(A[i],A[largest]);        maxHeapify(A,n,largest);    }}void buildMaxHeap(int *A,int n){    for(int i=n/2-1;i>=0;--i)maxHeapify(A,n,i);  }void heapSort(int *A,int n){    buildMaxHeap(A,n);    for(int i=n-1;i>=1;--i)    {        swap(A[0],A[i]);        maxHeapify(A,i,0);    }}

4.快速排序
平均时间复杂度O(nlogn)，最优时间复杂度O(nlogn)，最差时间复杂度O(n^2)，空间复杂度从O(logn)到O(n)，不稳定。

int partition(int *A,int p,int r){    int x=A[r],i=p-1;    for(int j=p;j<r;++j)    {        if(A[j]<=x)swap(A[++i],A[j]);    }    swap(A[i+1],A[r]);    return i+1;}void quickSort(int *A,int p,int r){    if(p<r)    {        int q=partition(A,p,r);        quickSort(A,p,q-1);        quickSort(A,q+1,r);    }}

5.冒泡排序
时间复杂度O(n^2)，空间复杂度O(1)，稳定。

void bubbleSort(int *A,int n){    for(int i=0;i<=n-2;++i)    {        for(int j=0;j<=n-2-i;++j)        {            if(A[j]>A[j+1])swap(A[j],A[j+1]);        }    }}

6.选择排序
时间复杂度O(n^2)，空间复杂度O(1)，不稳定。

void selectionSort(int *A,int n){    for(int i=0;i<=n-2;++i)    {        int min=i;        for(int j=i+1;j<=n-1;++j)        {            if(A[j]<A[min])min=j;        }        swap(A[i],A[min]);    }}

7.计数排序
时间复杂度O(n+k)，空间复杂度O(n+k)，稳定。

void countingSort(int *A,int *B,int n,int k)  {        int *C=new int[k+1]();         for(int i=0;i<n;++i)++C[A[i]];      for(int i=1;i<=k;++i)C[i]+=C[i-1];      for(int i=n-1;i>=0;--i)      {          B[C[A[i]]-1]=A[i];          --C[A[i]];      }      delete [] C;  }  

8.基数排序
时间复杂度O(kn)，空间复杂度O(kn)，稳定。

void radixSort(int *A,int n,int k){    int *B=new int[n],*C=new int[10](),radix=1;    for(int i=0;i<k;++i)    {        for(int i=0;i<n;++i)++C[A[i]/radix%10];          for(int i=1;i<10;++i)C[i]+=C[i-1];          for(int i=n-1;i>=0;--i)          {              B[C[A[i]/radix%10]-1]=A[i];              --C[A[i]/radix%10];          }        for(int i=0;i<n;++i)A[i]=B[i];        radix*=10;    }    delete [] B,C;}

9.桶排序
时间复杂度O(n)，空间复杂度O(n)，稳定。

struct node{    double value;    node *next;    node(double x=-1):value(x),next(NULL){}};void bucketSort(double *A,int n){    node *B=new node[n];    for(int i=0;i<n;++i)    {        node *p=new node(A[i]),*prev=B+int(floor(n*A[i])),*cur=prev->next;        for(;cur&&cur->value<=A[i];prev=cur,cur=cur->next);        p->next=cur;        prev->next=p;    }    for(int i=0,j=0;i<n;++i)    {        for(node *cur=B[i].next;cur;A[j++]=cur->value,cur=cur->next);    }    delete [] B;}