7种常用排序算法总结：

7种排序算法总结：

整理的时候资源来自网络。不妥的联系我。谢谢。

事实上，目前还没有十全十美的排序算法，有优点就会有缺点，即使是快速排序法，也只是在整体性能上优越，它也存在排序不稳定、需要大量辅助空间、对少量数据排序无优势等不足。因此我们就来从多个角度来剖析一下提到的各种排序的长与短。
　　我们将7种算法的各种指标进行对比，如表9‐10‐1所示。
　　　　　　　　　　　　　　　　　　　　　表9‐10‐1

排序方法             平均情况　　　　　　最好情况　　  最坏情况　　　　辅助空间　　稳定性
冒泡排序　　　　O(n2)                        O(n)                   O(n2)O(1)        稳定
简单选择排序　　O(n2)                O(n2)     O(n2) O(1)稳定
直接插入排序　　O(n2)                O(n)    O(n2)O(1) 稳定
希尔排序　　　　O(nlogn)-O(n2)           O(n1.3)              O(n2)O(1)不稳定
堆排序　　　　　O(nlogn)                            O(nlogn)            O(nlogn)O(1)不稳定
归并排序　　　　O(nlogn)     O(nlogn)            O(nlogn)O(n)稳定
快速排序　　　　O(nlogn)                            O(nlogn)          O(n2) O(logn)～O(n)不稳定

从算法的简单性来看，我们将7种算法分为两类：
 简单算法：冒泡、简单选择、直接插入。
 改进算法：希尔、堆、并、快速。
　　从平均情况来看，显然最后3种改进算法要胜过希尔排序，并远远胜过前3种简单算法。
　　从最好情况看，反而冒泡和直接插入排序要更胜一筹，也就是说，如果你的待排序序列总是基本有序，反而不应该考虑后4种复杂的改进算法。
　　从最坏情况看，堆排序与归并排序又强过快速排序以及其他简单排序。
　　从这三组时间复杂度的数据对比中，我们可以得出这样一个认识。堆排序和归并排序就像两个参加奥数考试的优等生，心理素质强，发挥稳定。而快速排序像是很情绪化的天才，心情好时表现极佳，碰到较糟糕环境会变得差强人意。但是他们如果都来比赛计算个位数的加减法，它们反而算不过成绩极普通的冒泡和直接插入。
　　从空间复杂度来说，归并排序强调要马跑得快，就得给马吃个饱。快速排序也有相应的空间要求，反而堆排序等却都是少量索取，大量付出，对空间要求是O(1)。如果执行算法的软件所处的环境非常在乎内存使用量的多少时，选择归并排序和快速排序就不是一个较好的决策了。
　　从稳定性来看，归并排序独占鳌头，我们前面也说过，对于非常在乎排序稳定性的应用中，归并排序是个好算法。
　　从待排序记录的个数上来说，待排序的个数n越小，采用简单排序方法越合适。反之，n越大，采用改进排序方法越合适。这也就是我们为什么对快速排序优化时，增加了一个阀值，低于阀值时换作直接插入排序的原因。
      从表9‐10‐1的数据中，似乎简单选择排序在3种简单排序中性能最差，其实也不完全是，比如，如果记录的关键字本身信息量比较大（例如，关键字都是数十位的数字），此时表明其占用存储空间很大，这样移动记录所花费的时间也就越多，我们给出3种简单排序算法的移动次数比较，如表9‐10‐2所示。

                              表9-10-2

排序方法　　　　平均情况　　最好情况　　最坏情况
冒泡排序　　　　O(n2)0 O(n2)
简单选择排序　　O(n) 0 O(n)
直接插入排序　　O(n2) O(n) O(n2)

　　你会发现，此时简单选择排序就变得非常有优势，原因也就在于，它是通过大量比较后选择明确记录进行移动，有的放矢。因此对于数据量不是很大而记录的关键字信息量较大的排序要求，简单排序算法是占优的。另外，记录的关键字信息量大小对那四个改进算法影响不大。
　　总之，从综合各项指标来说，经过优化的快速排序是性能最好的排序算法，但是不同的场合我们也应该考虑使用不同的算法来应对它。

一、冒泡排序：

原理：将序列划分为无序和有序区，不断通过交换较大元素至无序区尾完成排序。

要点：设计交换判断条件，提前结束以排好序的序列循环。

实现：

int BubbleSort(int  L[],int length)
{
int i,j;
int temp;
int ischanged = 0;//设计跳出条件
printf("BubbleSort :\n");
for(i=1;i<length;i++)
{
ischanged= 0;
for(j=length-1;j>=i;j--)
{
if(L[j]<L[j-1])//如果发现较重元素就向后移动,这里比较前后两
// 个相邻元素的大小，若该条件一直不满足则说明数据是有序的
     {
     temp=L[j];
     L[j]=L[j-1];
     L[j-1]=temp;
     ischanged= 1;
     }
}
if(ischanged== 0)//若没有移动则说明序列已经有序，直接跳出
break;
}
return 0;
}

二、           简单选择排序：

原理：将序列划分为无序和有序区，寻找无序区中的最小值和无序区的首元素交换，使得有序区扩大一个，循环最终完成全部排序。

实现：

void SelectSort(int  L[],int length)
{
int i,j,k,temp;//分别为有序区，无序区，无序区最小元素指针
for(i=0;i<length;i++)
{
k=i;
for(j=i+1;j<length;j++)
{
if(L[j]<L[k])
k=j;
}
if(k!=i)//若发现最小元素，则移动到有序区
{
temp=L[k];
L[k]=L[i];
L[i]=temp;
}
}
}

三、直接插入排序：

原理：将数组分为无序区和有序区两个区，然后不断将无序区的第一个元素按大小顺序插入到有序区中去，最终将所有无序区元素都移动到有序区完成排序。

要点：设立哨兵，作为临时存储和判断数组边界之用。

实现：

intInsertSort(int L[],int length)
{
    int i,j,temp;
    printf("InsertSort :\n");
    for(i=0;i<length-1;i++)
    {
        j = i+1;
        if(L[j] < L[i])
        {
            temp = L[j];    //存储待排序元素
            while(temp < L[i]){ //循环中找到需要插入的位置
            L[i+1] = L[i];
            i--;
        }
            L[++i] = temp;//将存储的元素数据插入到相应位置
            i = j - 1;// 还原外部循环的下标
        }
    }
    return 0;
}

四、希尔排序：

原理：又称增量缩小排序。先将序列按增量划分为元素个数相同的若干组，使用直接插入排序法进行排序，然后不断缩小增量直至为1，最后使用直接插入排序完成排序。

要点：增量的选择以及排序最终以1为增量进行排序结束。

实现：

voidShellSort(int L[],int length)
{
int d =length>>1;//length = length/2;
int i,j,temp;
while(d>=1 ){
    for(i = d;i<length;i++)
    {
        temp = L[i];
        j = i - d;
        while(j>=0 && temp <L[j]){
            L[j+d] = L[j];
            j = j - d;
        }
        L[j+d] = temp;
    }
    d >>= 1;
}

五、堆排序：

原理：利用大根堆或小根堆思想，首先建立堆，然后将堆首与堆尾交换，堆尾之后为有序区。

要点：建堆、交换、调整堆

实现：

int MAX_Heapify(intA[],int i,int length)
{
 int l,r,largest;
 //size = sizeof(A)/sizeof(int);
 l = i*2+1;
 r = i*2 + 2;
 if(l < length && A[l] > A[i])
  largest = l;
 else
  largest = i;
 if(r < length && A[r] >A[largest])
  largest = r;
 if(largest != i)
 {
  int tmp = A[i];
  A[i] = A[largest];
  A[largest] = tmp;
  MAX_Heapify(A,largest,length);
 }
 return 0;
}
int build_heap(intA[],int length)
{
 int i;
 //size = sizeof(A)/sizeof(int);
 for(i = (length-1)/2;i>=0;i--)
  MAX_Heapify(A,i,length);
 return 0;
}
int heap_sort(intA[],int length)
{
 int i,tmp;
 int size = length;
 build_heap(A,length);
 for(i = size-1;i>0;i--)
 {
  tmp = A[0];
  A[0] = A[i];
  A[i]=tmp;
  size--;
  MAX_Heapify(A,0,size);
 }
 return 0;
}

六、归并排序：

原理：将原序列划分为有序的两个序列，然后利用归并算法进行合并，合并之后即为有序序列。

要点：归并、分治

实现：

void Merge(int c[], intd[], int l, int m, int r)
{
 // 把c[l:m]] 和c[m:r] 归并到d [ l : r ] .
 int i=l; // 第一段的游标
 int q;
 int j=m+1; // 第二段的游标
 int k=l; // 结果的游标
 //只要在段中存在i和j，则不断进行归并
 while ((i<=m)&&(j<=r))
 {
  if(c[i]<=c[j])
   d[k++]=c[i++];
  else
   d[k++]=c[j++];
 }
 // 考虑余下的部分
 if(i>m)
 {
  for(q=j;q<=r;q++)
   d[k++]=c[q];
 }
 else
 {
  for(q=i;q<=m;q++)
   d[k++]=c[q];
 }
}
void MergePass(intx[],int y[],int s,int n)
{
 // 归并大小为s的相邻段
 int i=0,j;
 while(i<=n-2*s)
 {
  // 归并两个大小为s的相邻段
  Merge(x,y,i,i+s-1,i+2*s-1);
  i=i+2*s;
 }
 // 剩下不足2个元素
 if(i+s<n)
  Merge(x,y,i,i+s-1,n-1);
 else
  for(j=i;j<=n-1;j++)
   // 把最后一段复制到y
   y[j] = x[j];
}
void MergeSort(intL[],int length)
{
 //使用归并排序算法对a[0:n-1] 进行排序
 int* b=(int*)malloc(sizeof(int)*length);
 int s=1; // 段的大小
 while(s<length)
 {
  MergePass(L,b,s,length); // 从a归并到b
  s+=s;
  MergePass(b,L,s,length); // 从b 归并到a
  s+=s;
 }
 free(b);
}

七、快速排序：

原理：快速排序采用了一种分治的策略，通常称其为分治法，其基本思想是：将原问题分解为若干个规模更小但结构与原问题相似的子问题。递归地解这些子问题，然后将这些子问题的解组合为原问题的解。
    快速排序的具体过程如下：
    第一步，在待排序的n个记录中任取一个记录，以该记录的排序码为准，将所有记录分成两组，第1组各记录的排序码都小于等于该排序码，第2组各记录的排序码都大于该排序码，并把该记录排在这两组中间。
    第二步，采用同样的方法，对左边的组和右边的组进行排序，直到所有记录都排到相应的位置为止。

代码如下:

void Quick(int L[],int low,int high) //low和high是数组的下标
{
   if(low<high)
   {
        intt=L[low];
        int l=low,h=high;
        while(l<h)
        {
            while((L[h]>=t) &&(l<h) ) h--;
            if(l<h)
            {
                L[l]=L[h];
                l++;
            }
            while((L[l]<t)&&(l<h))l++;
            if(l<h)
           {
                L[h]=L[l];
                h--;
            }
        }
        L[l]=t;
        if(low< l){
            Quick(L,low,l-1);
        }
        if(l< high){
            Quick(L,l+1,high);
        }
   }
}
void Quick_Sort(int L[],int length)
{
    Quick(L,0,length-1);
}

 

自己测试用到的main()函数：

int main(void)
{
       int*a,*b;
       intnum = 10;
       inti = 0,j;
       int(*fun[7])(int*,int);
       fun[0]= BubbleSort;
       fun[1]= SelectSort;
       fun[2]= InsertSort;
       fun[3]= HeapSort;
       fun[4]= QuickSort;
       fun[5]= MergeSort;
       fun[6]= ShellSort;
       //函数指针
      
       a= (int*)malloc(sizeof(int)*num);
       if(a==NULL)
{
       printf(“malloc a error!\n”);
       return 0;
}
       for(i=0;i<num;i++)
       {
              a[i]= rand()%1000;
              printf("%d,",a[i]);
       }
       printf("\naftersort :\n");
       b= (int*)malloc(sizeof(int)*num);
       if(b==NULL)
{
       printf(“malloc berror !\n”);
       return 0;
}
 
       for(i=0;i<7;i++)
       {     
              printf("iis %d\n",i);
              for(j=0;j<num;j++)
                     b[j]= a[j];
              (fun[i])(b,num);
              for(j= 0;j<num;j++){
                     printf("%d,",b[j]);
              }
              printf("\n");
       }
       free(b);
       free(a);
}

 

由于本人基础较差，整理的时候难免有问题，麻烦各位把看到的问题贴出来，共同学习学习，谢谢了。