常用排序算法

1、插入排序：假设数组A[0,...,n-1]，A[0,...,p]按照从小到大的顺序排序完毕，将A[p+1,...,n-1]中元素一次与之前元素比较，并插入至相应位置，算法复杂度为n^2(符号省略，下同)

void INSERT_SORT(int *A,int len)

{

for(int i=1;i<len;i++)

 {

    int key=A[i];

    int j=i-1;

    while(j>=0&&A[j]>key)

    {

    A[j+1]=A[j]; 

   j--;

    }   

   A[j+1]=key;

}

}

2、冒泡排序：不断比较相邻两个元素，若前者大于后者，二者交换位置，直至遍历完全，算法复杂度n^2

 void BUBBLE_SORT(int* A,int len)

{

  for(int i=1;i<len;i++)//正序遍历

    for(int j=0;j<len-i;j++)

    {

    if(a[j]>a[j+1])

      {

        int tmp=a[j+1];

       a[j+1]=a[j];

       a[j]=tmp;

      }

    }

}

3、选择排序：从未排序部分中以此选出最小元素，置入已排序部分，算法复杂度n^2

 void SELECT_SORT(int *A,int len)

{

  for(int i=0;i<len-1;i++)

   {

    int min_index=i;

    for(int j=i+1;j<len;j++)

       if(A[j]<A[min_index])  min_index=j;

    if(min_index!=i)

      {

       int tmp=A[i];

      A[i]=A[min_index];

      A[min_index]=A[i];

      }

   }

}

4、归并排序：分成两部分分别排序，再将排序好两部分合并，递归完成，算法复杂度nlogn

 void MERGE(int *A,int p,int q,int r)

{

   int n1=q-p+1;

   int n2=r-q;

   int *L=new int[n1];

   int *R=new int[n2];

   for(int i=0;i<n1;i++)

     L[i]=A[p+i];

   for(int i=0;i<n2;i++)

    R[i]=A[i+q];

  int i=1;

  int j=1;

   for(int k=p;k<=r;k++)

   {

  if(L[i]<=R[j])

  {A[k]=L[i];i++;}

  else

  {A[k]=R[j];j++;}

   } 

}

void MERGE_SORT(int *A,int p,int r)

{

   if(p<r)

   {

   int q=(p+r)/2;

   MERGE_SORT(A,p,q);

   MERGE_SORT(A,q+1,r)

   MERGE(A,p,q,r);

   }

}

5、堆排序：这里的堆是一个近似完全二叉树，父结点>=或<=子结点的是最大或最小堆

void MAX_HEAPIFY(int* A,int i,int len)//维护最大堆

{

   int l=2*i+1;

   int r=2*i+2;

   int largest=i;

   if(l<len&&A[l]>A[largest])  largest=l;

   if(r<len&&A[r]>A[largest]) largest=r;

   if(largest!=i){

   int tmp=A[i];

   A[i]=A[largest];

   A[largest]=tmp;

   MAX_HEAPIFY(A,largest,len);

  }

}

void BUILD_MAX_HEAP(int* A,int len){//建堆

    for(int i=len/2-1;i>=0;i--){

      MAX_HEAPIFY(A,i,len);

   }

}

 

void HEAPSORT(int* A,int len)//堆排序

{

  BUILD_MAX_HEAP(A,len);

  for(int i=len-1;i>0;i--){

     int tmp=A[0];

     A[0]=A[i];

     A[i]=tmp;

     len=len-1;

     MAX_HEAPIFY(a,1,len);

  }

}

6、快速排序：数组A[p,...,r]划分为两子数组A[p,...,q-1]和A[q+1,...,r]，使得前者每个元素小于A[q]，后者每个元素大于A[q]，递归完成，算法复杂度n^2

 int PARTION(int* A,int p,int r)//以A[r]为基元

{

   int x=A[r];

   int i=p-1;

   for(int j=p;j<r;j++)

   {

   if(A[j]<=x){

      i++;

      int tmp=A[i];

      A[i]=A[j];

      A[j]=tmp;

   }

   }

   int tmp=A[i+1];

      A[i+1]=A[r];

      A[r]=tmp;

 

return i+1;

}

void QUICKSORT(int* A,int p,int r)

{

if(p<r)

{

  int q=PARTION(A,p,r);

  QUICKSORT(A,p,q-1);

  QUICKSORT(A,q+!,r);

}

}

 

7、计数排序：对每一个输入元素x，确定小于x的元素个数，放在输出数组相应位置上；当有几个相等的元素时，从按序放置

A中存储元素为非负整数

void COUNTING_SORT(int* A,int* B, int k,int len)//k为A中最大元素取值，len为A中存放元素个数

{

    int *C=new int[k+1];

    for(int i=0;i<=k;i++)

         C[i]=0;

     for(int j=0;j<len;j++)//等于各取值的元素数目

        C[A[j]]=C[A[j]]+1;

      for(int i=0;i<=k;i++)//小于各取值的元素数目

        C[i]+=C[i-1];

     

      for(int j=len-1;j>=0;j--)

      {

         B[C[A[j]]]=A[j];

         C[A[j]]=C[A[j]]-1;

      }//输出数组

}

 

8、基数排序：从低位只高位依次比较排序，算法复杂度d(n+k)

认为数字都是非负整数

int getDigit(int a,int k)//获得第k位数字

{

   for(int i=1;i<k;i++)

    {

    a=a/10;

    }

    return a%10;

}

 

void RADIX_SORT(int* A,int d,int len)

{

  for(int i=0;i<d;i++)

  {

   int *B=new int[len];

   for(int j=0;j<len;j++)

   {

   B[j]=getDigit(A[j],i+1);

   }

    //数组A按照第i位数字排序

    for(int j=1;j<len;j++)//插入排序

    {

    int key=B[j];

    int k=j-1;

    while(k>=0&&B[k]>key)

    {

    A[k+1]=A[k];

    k--;

    }

    A[k+1]=A[j];

    } 

  }

}