几种排序算法比较

转自:点击打开链接

一、分类与性能


1、稳定排序和非稳定排序 简单地说就是所有相等的数经过某种排序方法后,仍能保持它们在排序之前的相对次序,我们就说这种排序方法是稳定的。反之,就是非稳定的。 比如:一组数排序前是a1,a2,a3,a4,a5,其中a2=a4,经过某种排序后为a1,a2,a4,a3,a5,则我们说这种排序是稳定的,因为a2排序前在a4的前面,排序后它还是在a4的前面。假如变成a1,a4,a2,a3,a5就不是稳定的了。

2、内排序和外排序 在排序过程中,所有需要排序的数都在内存,并在内存中调整它们的存储顺序,称为内排序; 在排序过程中,只有部分数被调入内存,并借助内存调整数在外存中的存放顺序排序方法称为外排序。

3、算法的时间复杂度和空间复杂度 所谓算法的时间复杂度,是指执行算法所需要的计算工作量。 一个算法的空间复杂度,一般是指执行这个算法所需要的内存空间。

二、各类排序算法分析


1、冒泡排序 ==================================================== 算法思想简单描述: 在要排序的一组数中,对当前还未排好序的范围内的全部数,自上而下对相邻的两个数依次进行比较和调整,让较大的数往下沉,较小的往上冒。即:每当两相邻的数比较后发现它们的排序与排序要求相反时,就将它们互换。 下面是一种改进的冒泡算法,它记录了每一遍扫描后最后下沉数的位置k,这样可以减少外层循环扫描的次数。 冒泡排序是稳定的。算法时间复杂度O(n2)–[n的平方] =====================================================

  1. #i nclude <iostream.h>
  2. void BubbleSort(int* pData,int Count)
  3. {
  4. int iTemp;
  5. for(int i=1;i<Count;i++)
  6.        {
  7.          for(int j=Count1;j>=i;j)
  8.                 {
  9.                   if(pData[j]<pData[j1])
  10.                             {
  11.                               iTemp = pData[j1];
  12.                               pData[j1]= pData[j];
  13.                               pData[j]= iTemp;
  14.                             }
  15.                 }
  16.        }
  17. }
  18. void main()
  19. {
  20. int data[]= {10,9,8,7,6,5,4};
  21. BubbleSort(data,7);
  22. for (int i=0;i<7;i++)
  23.             cout<<data[i]<<” “;
  24. cout<<“\n”;
  25. }

倒序(最糟情况)  第一轮:10,9,8,7->10,9,7,8->10,7,9,8->7,10,9,8(交换3次)  第二轮:7,10,9,8->7,10,8,9->7,8,10,9(交换2次)  第一轮:7,8,10,9->7,8,9,10(交换1次)  循环次数:6次  交换次数:6次  其他:  第一轮:8,10,7,9->8,10,7,9->8,7,10,9->7,8,10,9(交换2次)  第二轮:7,8,10,9->7,8,10,9->7,8,10,9(交换0次)  第一轮:7,8,10,9->7,8,9,10(交换1次)  循环次数:6次  交换次数:3次         上面我们给出了程序段,现在我们分析它:这里,影响我们算法性能的主要部分是循环和交换,显然,次数越多,性能就越差。从上面的程序我们可以看出循环的次数是固定的,为1+2+…+n-1。写成公式就是1/2*(n-1)*n。 现在注意,我们给出O方法的定义:         若存在一常量K和起点n0,使当n>=n0时,有f(n)<=K*g(n),则f(n) = O(g(n))。(呵呵,不要说没 学好数学呀,对于编程数学是非常重要的!!!)        现在我们来看1/2*(n-1)*n,当K=1/2,n0=1,g(n)=n*n时,1/2*(n-1)*n<=1/2*n*n=K*g(n)。所以f(n) =O(g(n))=O(n*n)。所以我们程序循环的复杂度为O(n*n)。再看交换。从程序后面所跟的表可以看到,两种情况的循环相同,交换不同。其实交换本身同数据源的有序程度有极大的关系,当数据处于倒序的情况时,交换次数同循环一样(每次循环判断都会交换),复杂度为O(n*n)。当数据为正序,将不会有交换。复杂度为O(0)。乱序时处于中间状态。正是由于这样的原因,我们通常都是通过循环次数来对比算法。

2、选择排序 ==================================================== 算法思想简单描述: 在要排序的一组数中,选出最小的一个数与第一个位置的数交换;然后在剩下的数当中再找最小的与第二个位置的数交换,如此循环到倒数第二个数和最后一个数比较为止。 选择排序是不稳定的。算法复杂度O(n2)–[n的平方] ====================================================

  1. #i nclude <iostream.h>
  2. void SelectSort(int* pData,int Count)
  3. {
  4. int iTemp;
  5. int iPos;
  6. for(int i=0;i<Count1;i++)
  7. {
  8.  iTemp = pData[i];
  9.  iPos = i;
  10.  for(int j=i+1;j<Count;j++)
  11.  {
  12.   if(pData[j]<iTemp)
  13.   {
  14.    iTemp = pData[j];
  15.    iPos = j;
  16.   }
  17.  }
  18.  pData[iPos]= pData[i];
  19.   pData[i]= iTemp;
  20.   }
  21. }
  22. void main()
  23. {
  24. int data[]= {10,9,8,7,6,5,4};
  25. SelectSort(data,7);
  26. for (int i=0;i<7;i++)
  27.             cout<<data[i]<<” “;
  28. cout<<“\n”;
  29. }

倒序(最糟情况)  第一轮:10,9,8,7->(iTemp=9)10,9,8,7->(iTemp=8)10,9,8,7->(iTemp=7)7,9,8,10(交换1次)  第二轮:7,9,8,10->7,9,8,10(iTemp=8)->(iTemp=8)7,8,9,10(交换1次)  第一轮:7,8,9,10->(iTemp=9)7,8,9,10(交换0次)  循环次数:6次  交换次数:2次 其他:  第一轮:8,10,7,9->(iTemp=8)8,10,7,9->(iTemp=7)8,10,7,9->(iTemp=7)7,10,8,9(交换1次)  第二轮:7,10,8,9->(iTemp=8)7,10,8,9->(iTemp=8)7,8,10,9(交换1次)  第一轮:7,8,10,9->(iTemp=9)7,8,9,10(交换1次)  循环次数:6次  交换次数:3次         遗憾的是算法需要的循环次数依然是1/2*(n-1)*n。所以算法复杂度为O(n*n)。我们来看他的交换。由于每次外层循环只产生一次交换(只有一个最小值)。所以f(n)<=n 所以我们有f(n)=O(n)。所以,在数据较乱的时候,可以减少一定的交换次数。

3、直接插入排序 ==================================================== 算法思想简单描述: 在要排序的一组数中,假设前面(n-1) [n>=2] 个数已经是排好顺序的,现在要把第n个数插到前面的有序数中,使得这n个数也是排好顺序的。如此反复循环,直到全部排好顺序。 直接插入排序是稳定的。算法时间复杂度O(n2)–[n的平方] =====================================================

  1. #include <iostream.h>
  2. void SelectSort(int* pData,int Count)
  3. {
  4. int iTemp;
  5. int iPos;
  6. for(int i=0;i<Count1;i++)
  7. {
  8.  iTemp = pData[i];
  9.  iPos = i;
  10.  for(int j=i+1;j<Count;j++)
  11.  {
  12.   if(pData[j]<iTemp)
  13.   {
  14.    iTemp = pData[j];
  15.    iPos = j;
  16.   }
  17.  }
  18.  pData[iPos]= pData[i];
  19.   pData[i]= iTemp;
  20.   }
  21. }
  22. void main()
  23. {
  24. int data[]= {10,9,8,7,6,5,4};
  25. SelectSort(data,7);
  26. for (int i=0;i<7;i++)
  27.             cout<<data[i]<<” “;
  28. cout<<“\n”;
  29. }

倒序(最糟情况)  第一轮:10,9,8,7->9,10,8,7(交换1次)(循环1次)  第二轮:9,10,8,7->8,9,10,7(交换1次)(循环2次)  第一轮:8,9,10,7->7,8,9,10(交换1次)(循环3次)  循环次数:6次  交换次数:3次 其他:  第一轮:8,10,7,9->8,10,7,9(交换0次)(循环1次)  第二轮:8,10,7,9->7,8,10,9(交换1次)(循环2次)  第一轮:7,8,10,9->7,8,9,10(交换1次)(循环1次)  循环次数:4次  交换次数:2次        上面结尾的行为分析事实上造成了一种假象,让我们认为这种算法是简单算法中最好的,其实不是,因为其循环次数虽然并不固定,我们仍可以使用O方法。从上面的结果可以看出,循环的次数f(n)<= 1/2*n*(n-1)<=1/2*n*n。所以其复杂度仍为O(n*n)(这里说明一下,其实如果不是为了展示这些简单排序的不同,交换次数仍然可以这样推导)。现在看交换,从外观上看,交换次数是O(n)(推导类似选择法),但我们每次要进行与内层循环相同次数的‘=’操作。正常的一次交换我们需要三次‘=’ 而这里显然多了一些,所以我们浪费了时间。        个人认为在简单排序算法中,选择法是最好的。

4、希尔排序 ==================================================== 算法思想简单描述: 在直接插入排序算法中,每次插入一个数,使有序序列只增加1个节点,并且对插入下一个数没有提供任何帮助。如果比较相隔较远距离(称为增量)的数,使得数移动时能跨过多个元素,则进行一次比较就可能消除 多个元素交换。D.L.shell于1959年在以他名字命名的排序算法中实现了这一思想。算法先将要排序的一组数按某个增量d分成若干组,每组中记录的下标相差d.对每组中全部元素进行排序,然后再用一个较小的增量对它进行,在每组中再进行排序。当增量减到1时,整个要排序的数被分成 一组,排序完成。 下面的函数是一个希尔排序算法的一个实现,初次取序列的一半为增量,以后每次减半,直到增量为1。 希尔排序是不稳定的。 =====================================================  这个排序非常复杂,看了程序就知道了。 首先需要一个递减的步长,这里我们使用的是9、5、3、1(最后的步长必须是1)。工作原理是首先对相隔9-1个元素的所有内容排序,然后再使用同样的方法对相隔5-1个元素的排序,以次类推。 

  1. #i nclude <iostream.h>
  2. void ShellSort(int* pData,int Count)
  3. {
  4. int step[4];
  5. step[0]= 9;
  6. step[1]= 5;
  7. step[2]= 3;
  8. step[3]= 1;
  9. int i,Temp;
  10. int k,s,w;
  11. for(int i=0;i<4;i++)
  12.            {
  13.              k = step[i];
  14.              s = k;
  15.             for(int j=k;j<Count;j++)
  16.                        {
  17.                          iTemp = pData[j];
  18.                          w = jk;//求上step个元素的下标
  19.                          if(s==0)
  20.                                      {
  21.                                        s =k;
  22.                                        s++;
  23.                                        pData[s]= iTemp;
  24.                                      }
  25.                         while((iTemp<pData[w])&& (w>=0)&& (w<=Count))
  26.                                      {
  27.                                        pData[w+k]= pData[w];
  28.                                        w = wk;
  29.                                      }
  30.                         pData[w+k]= iTemp;
  31.                      }
  32.           }
  33. }
  34. void main()
  35. {
  36. int data[]= {10,9,8,7,6,5,4,3,2,1,10,1};
  37. ShellSort(data,12);
  38. for (int i=0;i<12;i++)
  39.             cout<<data[i]<<” “;
  40. cout<<“\n”;
  41. }

       呵呵,程序看起来有些头疼。不过也不是很难,把s==0的块去掉就轻松多了,这里是避免使用0 步长造成程序异常而写的代码。这个代码我认为很值得一看。这个算法的得名是因为其发明者的名字D.L.SHELL。依照参考资料上的说法:“由于复杂的数学原因避免使用2的幂次步长,它能降低算法效率。”另外算法的复杂度为n的1.2次幂。同样因为非常复杂并 “我也不知道过程”,我们只有结果了。

5、快速排序 ==================================================== 算法思想简单描述: 快速排序是对冒泡排序的一种本质改进。它的基本思想是通过一趟扫描后,使得排序序列的长度能大幅度地减少。在冒泡排序中,一次扫描只能确保最大数值的数移到正确位置,而待排序序列的长度可能只减少1。快速排序通过一趟扫描,就能确保某个数(以它为基准点吧)的左边各数都比它小,右边各数都比它大。然后又用同样的方法处理它左右两边的数,直到基准点的左右只有一个元素为止。它是由C.A.R.Hoare于1962年提出的。 显然快速排序可以用递归实现,当然也可以用栈化解递归实现。下面的函数是用递归实现的,有兴趣的朋友可以改成非递归的。 快速排序是不稳定的。最理想情况算法时间复杂度O(nlog2n),最坏O(n2) =====================================================

  1. #i nclude <iostream.h>
  2. void run(int* pData,intleft,intright)
  3. {
  4. int i,j;
  5. int middle,iTemp;
  6. i = left;
  7. j = right;
  8. middle = pData[(left+right)/2];//求中间值
  9. do{
  10.         while((pData[i]<middle)&& (i<right))//从左扫描大于中值的数
  11.                        i++;
  12.         while((pData[j]>middle)&& (j>left))//从右扫描大于中值的数
  13.                        j;
  14.         if(i<=j)//找到了一对值
  15.                       {
  16.                        //交换
  17.                         iTemp = pData[i];
  18.                         pData[i]= pData[j];
  19.                         pData[j]= iTemp;
  20.                         i++;
  21.                         j;
  22.                       }
  23. }while(i<=j);//如果两边扫描的下标交错,就停止(完成一次)
  24. //当左边部分有值(left<j),递归左半边
  25. if(left<j)
  26.           run(pData,left,j);
  27. //当右边部分有值(right>i),递归右半边
  28. if(right>i)
  29.           run(pData,i,right);
  30. }
  31. void QuickSort(int* pData,int Count)
  32. {
  33. run(pData,0,Count1);
  34. }
  35. void main()
  36. {
  37. int data[]= {10,9,8,7,6,5,4};
  38. QuickSort(data,7);
  39. for (int i=0;i<7;i++)
  40.            cout<<data[i]<<” “;
  41. cout<<“\n”;
  42. }

       这里我没有给出行为的分析,因为这个很简单,我们直接来分析算法:首先我们考虑最理想的情况         1.数组的大小是2的幂,这样分下去始终可以被2整除。假设为2的k次方,即k=log2(n)。         2.每次我们选择的值刚好是中间值,这样,数组才可以被等分。         第一层递归,循环n次,第二层循环2*(n/2)…… 所以共有n+2(n/2)+4(n/4)+…+n*(n/n) = n+n+n+…+n=k*n=log2(n)*n 所以算法复杂度为O(log2(n)*n) 其他的情况只会比这种情况差,最差的情况是每次选择到的middle都是最小值或最大值,那么他将变成交换法(由于使用了递归,情况更糟)。但是你认为这种情况发生的几率有多大??呵呵,你完全不必担心这个问题。实践证明,大多数的情况,快速排序总是最好的。如果你担心这个问题,你可以使用堆排序,这是一种稳定的O(log2(n)*n)算法,但是通常情况下速度要慢于快速排序(因为要重组堆)。

6、堆排序 ==================================================== 算法思想简单描述: 堆排序是一种树形选择排序,是对直接选择排序的有效改进。 堆的定义如下:具有n个元素的序列(h1,h2,…,hn),当且仅当满足(hi>=h2i,hi>=2i+1)或(hi<=h2i,hi<=2i+1)(i=1,2,…,n/2)时称之为堆。在这里只讨论满足前者条件的堆。 由堆的定义可以看出,堆顶元素(即第一个元素)必为最大项。完全二叉树可以很直观地表示堆的结构。堆顶为根,其它为左子树、右子树。 初始时把要排序的数的序列看作是一棵顺序存储的二叉树,调整它们的存储顺序,使之成为一个堆,这时堆的根节点的数最大。然后将根节点与堆的最后一个节点交换。然后对前面(n-1)个数重新调整使之成为堆。依此类推,直到只有两个节点的堆,并对它们作交换,最后得到有n个节点的有序序列。 从算法描述来看,堆排序需要两个过程,一是建立堆,二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数,二是反复调用渗透函数实现排序的函数。 堆排序是不稳定的。算法时间复杂度O(nlog2n)。 ==================================================== 

  1. void sift(int*x, int n, int s)
  2. {
  3.  int t, k, j;
  4.  t = *(x+s);
  5.  k = s;
  6.  j = 2*k+ 1;
  7.  while (j
  8.  {
  9.   if (j
  10. < *(x+j+1))*判断是否满足堆的条件:满足就继续下一轮比较,否则调整。*&& *(x+j)/> {
  11.    j++;
  12.   }
  13.     if (t<*(x+j))
  14.   {
  15.    *(x+k)= *(x+j);
  16.    k = j;
  17.    j = 2*k+ 1;
  18.   }
  19.   else
  20.   {
  21.    break;
  22.   }
  23.  }
  24.  *(x+k)= t;
  25. }
  26. void heap_sort(int*x, int n)
  27. {
  28.  int i, k, t;
  29.  int *p;
  30.  for (i=n/21; i>=0; i)
  31.  {
  32.   sift(x,n,i);
  33.  }
  34.  for (k=n1; k>=1; k)
  35.  {
  36.   t = *(x+0);
  37.   *(x+0)= *(x+k);
  38.   *(x+k)= t;
  39.   sift(x,k,0);
  40.  }
  41. }
  42. void main()
  43. {
  44.  #define MAX 4
  45.  int *p, i, a[MAX];
  46.  
  47.  p = a;
  48.  printf(“Input %d number for sorting :\n”,MAX);
  49.  for (i=0; i
  50.  {
  51.   scanf(“%d”,p++);
  52.  }
  53.  printf(“\n”);
  54.  
  55.  p = a;
  56.  select_sort(p,MAX);
  57.  for (p=a, i=0; i
  58.  {
  59.   printf(“%d “,*p++);
  60.  }
  61.  printf(“\n”);
  62.  system(“pause”);
  63. }

其他的交换法,双向冒泡法等等就不具体介绍了。  
三、几种排序算法的比较和选择 1. 选取排序方法需要考虑的因素:        (1) 待排序的元素数目n;        (2) 元素本身信息量的大小;        (3) 关键字的结构及其分布情况;        (4) 语言工具的条件,辅助空间的大小等。

四、小结:    (1) 若n较小(n <= 50),则可以采用直接插入排序或直接选择排序。由于直接插入排序所需的记录移动操作较直接选择排序多,因而当记录本身信息量较大时,用直接选择排序较好。    (2) 若文件的初始状态已按关键字基本有序,则选用直接插入或冒泡排序为宜。    (3) 若n较大,则应采用时间复杂度为O(nlog2n)的排序方法:快速排序、堆排序或归并排序。快速排序是目前基于比较的内部排序法中被认为是最好的方法。    (4) 在基于比较排序方法中,每次比较两个关键字的大小之后,仅仅出现两种可能的转移,因此可以用一棵二叉树来描述比较判定过程,由此可以证明:当文件的n个关键字随机分布时,任何借助于”比较”的排序算法,至少需要O(nlog2n)的时间。    (5) 当记录本身信息量较大时,为避免耗费大量时间移动记录,可以用链表作为存储结构。

    原文作者:排序算法
    原文地址: https://blog.csdn.net/yanghongche/article/details/52153786
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞