程序博客网 > 剑灵人男捏脸数据截图

冒泡排序、插入排序、选择排序、希尔排序、堆排序、归并排序等常用排序算法的比较

来源：互联网 发布：剑灵人男捏脸数据截图 编辑：程序博客网 时间：2024/06/06 16:49

掌握好常用的排序算法，在实际的项目开发中可以节省很多的时间。每一种排序算法在执行的效率上是存在差别的，这些微小的时间差，也许在平常的联系当中感觉不到，但是涉及到数据量比较大或者是在资源比较紧张的系统中就显得尤其的重要，比如嵌入式系统。下面简要介绍三种常用的排序算法以及他们的执行效率的比较。

       冒泡排序：最优为O(n),最坏为O(n^2),平均O(n^2）

       思路：将相邻的两个数比较，将较小的数调到前头；有n个数就要进行n-1趟比较，第一次比较中要进行n-1次两两比较，在第j趟比较中，要进行n-j次两两比较。

       实现代码：

[cpp] view plain copy
  1. <span style="font-size:14px;">     void BublleSort (int arr [], int count)  
  2.     {  
  3.         int i, j, temp;  
  4.         for(j=0; j<count-1; j++ ) /* 冒泡法要排序n-1次*/  
  5.             for(i=0; i<count-j-1; i++ )/* 值比较大的元素沉下去后，只把剩下的元素中的最大值再沉下去就可以啦 */  
  6.             {  
  7.                 if(arr[i]>arr[i+1])/* 把值比较大的元素沉到底 */  
  8.                 {  
  9.                     temp=arr[i+1];  
  10.                     arr[i+1]=arr[i];  
  11.                     arr[i]=temp;  
  12.                 }  
  13.             }  
  14.     }</span>  


为什么说冒泡法最佳时间复杂度为O(N)呢？因为冒泡法的算法得到了优化，如下：
[java] view plain copy
  1. public void bubbleSort(int arr[]) {  
  2.     boolean didSwap;  
  3.     for(int i = 0, len = arr.length; i < len - 1; i++) {  
  4.         didSwap = false;  
  5.         for(int j = 0; j < len - i - 1; j++) {  
  6.             if(arr[j + 1] < arr[j]) {  
  7.                 swap(arr, j, j + 1);  
  8.                 didSwap = true;  
  9.             }  
  10.         }  
  11.         if(didSwap == false)  
  12.             return;  
  13.     }      
  14. }  


       插入排序：最优为O(n),最坏为O(n^2),平均O(n^2）

       思路：在得到要排序的数组以后，讲数组分为两个部分，数组的第一个元素为一个部分，剩下的元素为一部分，然后从数组的第二个元素开始，和该元素以前的所有元素比较，如果之前的元素没有比该元素大的，那么该元素的位置不变，如果有元素的值比该元素大，那么记录他所在的位置；例如I，该元素的位置为k，则将从i到k位置上的所有元素往后移动一位，然后将k位置上的值移动到i位置上。这样就找到了K所在的位置。每一个元素都这样进行，最终就会得到排好顺序的数组。

       实现代码：

    

[cpp] view plain copy
  1. void InsertSort ( int arr[],int count)  
  2.     {  
  3.             int i,j,temp;  
  4.         for(i=1; i<count; i )//数组分两个部分，从第二个数组元素开始  
  5.         {  
  6.             temp = arr[i];//操作当前元素，先保存在其它变量中  
  7.             for(j=i; j>0 && arr[j]>temp; j--)//从当前元素的上一个元素开始查找合适的位置，一直查找到首元素，如果大则后移  
  8.             {  
  9.                 arr[ j ] = arr[ j - 1 ];  
  10.             }  
  11.             arr[ j ] = temp;                            //将当前元素放置在合适位置  
  12.         }  
  13.     }  

       选择排序：优为O(nlogn),最坏为O(n^2),平均O(nlogn)

       思路：

       首先以一个元素为基准，从一个方向开始扫描，比如从左到右扫描，以A[0]为基准，接下来从A[0]….A[9]中找出最小的元素，将其与A[0]交换。然后将其基准位置右移一位，重复上面的动作，比如，以A[1]为基准，找出A[1]~A[9]中最小的，将其与A[1]交换。一直进行到将基准位置移到数组最后一个元素时排序结束。

       实现代码：

[cpp] view plain copy
  1. void selectsort(int arr[], int n)  
  2. {  
  3.     int i = 0, j = 0, iindex = 0;  
  4.     int temp = 0;  
  5.     int iMin = 0;  
  6.     for (i = 0; i < n;i++)  
  7.     {  
  8.         iMin = arr[i];  
  9.         iindex = i;                         //未交换则不改变  
  10.         for (j = i + 1; j < n;j++)  
  11.         {  
  12.             if (arr[j] < iMin)  
  13.             {  
  14.                 iMin = arr[j];              //存储最小值  
  15.                 iindex = j;                 //存储最小值索引  
  16.             }  
  17.         }  
  18.         if ( i != iindex )  
  19.         {  
  20.             temp = arr[iindex];  
  21.             arr[iindex] = arr[i];               //最小值交换  
  22.             arr[i] = temp;  
  23.         }  
  24.           
  25.     }  
  26. }  




       效率比较：

       为了能够更加明显的查看其效果，将每个排序算法执行10000次。下面是测试程序主函数：

[cpp] view plain copy
  1. #include <stdio.h>  
  2. #include<stdlib.h>  
  3. #include <sys/time.h>  
  4. #include <unistd.h>  
  5.    
  6. #define MAX 6  
  7.    
  8. int array[MAX];  
  9. int count = MAX;  
  10.    
  11. /********创建数组，并输入元素************/  
  12. void BuildArray()  
  13. {  
  14.     int a,i=0;  
  15.     printf("请输入数组元素: ");  
  16.     for(; i<count; i )  
  17.     {  
  18.         scanf("%d", &a);  
  19.         array[i] = a;  
  20.     }  
  21.     printf("\n");  
  22. }  
  23. /**********遍历输出数组元素*************/  
  24. void Traverse(int arr[], int count)  
  25. {  
  26.     int i;  
  27.     printf("数组输出: ");  
  28.     for(i=0; i<count; i )  
  29.         printf("%d\t", arr[i]);  
  30.     printf("\n");  
  31. }  
  32. void BublleSort(int arr[], int count)  
  33. {  
  34.     int i,j,temp;  
  35.     for(j=0; j<count-1; j ) /* 气泡法要排序n-1次*/  
  36.         for(i=0; i<count-j-1; i )/* 值比较大的元素沉下去后，只把剩下的元素中的最大值再沉下去就可以啦 */  
  37.         {  
  38.             if(arr[i]>arr[i 1])/* 把值比较大的元素沉到底 */  
  39.             {  
  40.                 temp=arr[i 1];  
  41.                 arr[i 1]=arr[i];  
  42.                 arr[i]=temp;  
  43.             }  
  44.         }  
  45. }  
  46.    
  47. void InsertSort(int arr[],int count)  
  48. {  
  49.     int i,j,temp;  
  50.     for(i=1; i<count; i )//数组分两个部分，从第二个数组元素开始  
  51.     {  
  52.         temp = arr[i];//操作当前元素，先保存在其它变量中  
  53.         for(j=i-1; j>-1&&arr[j]>temp;j--)//从当前元素的上一个元素开始查找合适的位置，一直查找到首元素  
  54.         {  
  55.             arr[i] = arr[j];  
  56.             arr[j] = temp;  
  57.         }  
  58.     }  
  59. }  
  60.    
  61. void SelectSort(int arr[], int count)  
  62. {  
  63.     int i,j,min,temp;  
  64.     for(i=0; i<count; i )  
  65.     {  
  66.         min = arr[i];//以此元素为基准  
  67.         for(j=i 1; j<count; j )//从j往前的数据都是排好的，所以从j开始往下找剩下的元素中最小的  
  68.         {  
  69.             if(min>arr[j])//把剩下元素中最小的那个放到arr[j]中  
  70.             {  
  71.                 temp = arr[j];  
  72.                 arr[j] = min;  
  73.                 min = temp;  
  74.             }  
  75.         }  
  76.     }  
  77. }  
  78.    
  79. int main()  
  80. {  
  81.     int i;  
  82.     struct timeval tv1,tv2;  
  83.     struct timezone tz;  
  84.     BuildArray();//创建数组  
  85.     Traverse(array, count);//输出最初数组  
  86.     gettimeofday(&tv1,&tz);  
  87.     for(i=0;i<10000;i++)  
  88.         BublleSort(array, count);//冒泡排序  
  89.     gettimeofday(&tv2,&tz);  
  90.     printf("%d:%d/n",tv2.tv_sec-tv1.tv_sec,tv2.tv_usec-tv1.tv_usec);  
  91.     Traverse(array, count);//输出排序后的数组  
  92.    
  93.     gettimeofday(&tv1,&tz);  
  94.     for(i=0;i<10000;i++)  
  95.         InsertSort(array, count);//插入排序  
  96.     gettimeofday(&tv2,&tz);  
  97.     printf("%d:%d/n",tv2.tv_sec-tv1.tv_sec,tv2.tv_usec-tv1.tv_usec);  
  98.     Traverse(array, count);//输出排序后的数组  
  99.    
  100.     gettimeofday(&tv1,&tz);  
  101.     for(i=0;i<10000;i++)  
  102.         SelectSort(array, count);//插入排序  
  103.     gettimeofday (&tv2,&tz);  
  104.     printf("%d:%d/n",tv2.tv_sec-tv1.tv_sec,tv2.tv_usec-tv1.tv_usec);  
  105.     Traverse(array, count);//输出排序后的数组  
  106.     return 0;  
  107. }  
  108.    


编译：gcc –g –Wall sort_test.c –o sort_test

运行：./sort_test

结果如下：


通过多次测试，插入排序的速度最快。


来源： <http://blog.chinaunix.net/uid-26758209-id-3139356.html>

    希尔排序：

 希尔排序的实质就是分组插入排序，该方法又称缩小增量排序，因DL．Shell于1959年提出而得名。

 

该方法的基本思想是：先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。因为直接插入排序在元素基本有序的情况下（接近最好情况），效率是很高的，因此希尔排序在时间效率上比前两种方法有较大提高。

 

以n=10的一个数组49, 38, 65, 97, 26, 13, 27, 49, 55, 4为例

第一次 gap = 10 / 2 = 5

49   38   65   97   26   13   27   49   55   4

1A                                1B

        2A                               2B

                 3A                              3B

                         4A                             4B

                                  5A                          5B

1A,1B，2A,2B等为分组标记，数字相同的表示在同一组，大写字母表示是该组的第几个元素， 每次对同一组的数据进行直接插入排序。即分成了五组(49, 13) (38, 27) (65, 49)  (97, 55)  (26, 4)这样每组排序后就变成了(13, 49)  (27, 38)  (49, 65)  (55, 97)  (4, 26)，下同。

第二次 gap = 5 / 2 = 2

排序后

13   27   49   55   4    49   38   65   97   26

1A          1B         1C          1D          1E

       2A          2B          2C          2D          2E

第三次 gap = 2 / 2 = 1

4   26   13   27   38    49   49   55   97   65

1A   1B     1C    1D    1E      1F     1G    1H     1I     1J

第四次 gap = 1 / 2 = 0 排序完成得到数组：

4   13   26   27   38    49   49   55   65   97

 

下面给出严格按照定义来写的希尔排序

[cpp] view plain copy
  1. void shellsort1(int a[], int n)  
  2. {  
  3.     int i, j, gap;  
  4.   
  5.     for (gap = n / 2; gap > 0; gap /= 2) //步长  
  6.         for (i = 0; i < gap; i++)        //直接插入排序  
  7.         {  
  8.             for (j = i + gap; j < n; j += gap)   
  9.                 if (a[j] < a[j - gap])  
  10.                 {  
  11.                     int temp = a[j];  
  12.                     int k = j - gap;  
  13.                     while (k >= 0 && a[k] > temp)  
  14.                     {  
  15.                         a[k + gap] = a[k];  
  16.                         k -= gap;  
  17.                     }  
  18.                     a[k + gap] = temp;  
  19.                 }  
  20.         }  
  21. }  


很明显，上面的shellsort1代码虽然对直观的理解希尔排序有帮助，但代码量太大了，不够简洁清晰。因此进行下改进和优化，以第二次排序为例，原来是每次从1A到1E，从2A到2E，可以改成从1B开始，先和1A比较，然后取2B与2A比较，再取1C与前面自己组内的数据比较…….。这种每次从数组第gap个元素开始，每个元素与自己组内的数据进行直接插入排序显然也是正确的。
[cpp] view plain copy
  1. void shellsort2(int a[], int n)  
  2. {  
  3.     int j, gap;  
  4.       
  5.     for (gap = n / 2; gap > 0; gap /= 2)  
  6.         for (j = gap; j < n; j++)//从数组第gap个元素开始  
  7.             if (a[j] < a[j - gap])//每个元素与自己组内的数据进行直接插入排序  
  8.             {  
  9.                 int temp = a[j];  
  10.                 int k = j - gap;  
  11.                 while (k >= 0 && a[k] > temp)  
  12.                 {  
  13.                     a[k + gap] = a[k];  
  14.                     k -= gap;  
  15.                 }  
  16.                 a[k + gap] = temp;  
  17.             }  
  18. }  


来源： <http://blog.csdn.net/morewindows/article/details/6668714>

堆排序

堆排序与快速排序，归并排序一样都是时间复杂度为O(N*logN)的几种常见排序方法。学习堆排序前，先讲解下什么是数据结构中的二叉堆。

二叉堆的定义

二叉堆是完全二叉树或者是近似完全二叉树。

二叉堆满足二个特性：

1．父结点的键值总是大于或等于（小于或等于）任何一个子节点的键值。

2．每个结点的左子树和右子树都是一个二叉堆（都是最大堆或最小堆）。

当父结点的键值总是大于或等于任何一个子节点的键值时为最大堆。当父结点的键值总是小于或等于任何一个子节点的键值时为最小堆。下图展示一个最小堆：


由于其它几种堆（二项式堆，斐波纳契堆等）用的较少，一般将二叉堆就简称为堆。

堆的存储

一般都用数组来表示堆，i结点的父结点下标就为(i – 1) / 2。它的左右子结点下标分别为2 * i + 1和2 * i + 2。如第0个结点左右子结点下标分别为1和2。

堆的操作——插入删除

下面先给出《数据结构C++语言描述》中最小堆的建立插入删除的图解，再给出本人的实现代码，最好是先看明白图后再去看代码。


堆的插入

每次插入都是将新数据放在数组最后。可以发现从这个新数据的父结点到根结点必然为一个有序的数列，现在的任务是将这个新数据插入到这个有序数据中——这就类似于直接插入排序中将一个数据并入到有序区间中，对照《白话经典算法系列之二 直接插入排序的三种实现》不难写出插入一个新数据时堆的调整代码：

//  新加入i结点  其父结点为(i - 1) / 2 
[cpp] view plain copy
  1. void MinHeapFixup(int a[], int i)   
  2. {   
  3.     int j, temp;   
  4.    
  5.     temp = a[i];   
  6.     j = (i - 1) / 2;      //父结点   
  7.     while (j >= 0 && i != 0)   
  8.     {   
  9.         if (a[j] <= temp)   
  10.             break;   
  11.    
  12.         a[i] = a[j];     //把较大的子结点往下移动,替换它的子结点   
  13.         i = j;   
  14.         j = (i - 1) / 2;   
  15.     }   
  16.     a[i] = temp;   
  17. }    


更简短的表达为：

[cpp] view plain copy
  1. void MinHeapFixup(int a[], int i)   
  2. {   
  3.     for (int j = (i - 1) / 2; (j >= 0 && i != 0)&& a[i] > a[j]; i = j, j = (i - 1) / 2)   
  4.         Swap(a[i], a[j]);   
  5. }    


插入时：

//在最小堆中加入新的数据nNum 
[cpp] view plain copy
  1. void MinHeapAddNumber(int a[], int n, int nNum)   
  2. {   
  3.     a[n] = nNum;   
  4.     MinHeapFixup(a, n);   
  5. }    



堆的删除

按定义，堆中每次都只能删除第0个数据。为了便于重建堆，实际的操作是将最后一个数据的值赋给根结点，然后再从根结点开始进行一次从上向下的调整。调整时先在左右儿子结点中找最小的，如果父结点比这个最小的子结点还小说明不需要调整了，反之将父结点和它交换后再考虑后面的结点。相当于从根结点将一个数据的“下沉”过程。下面给出代码：

//  从i节点开始调整,n为节点总数 从0开始计算 i节点的子节点为 2*i+1, 2*i+2 
[cpp] view plain copy
  1. void MinHeapFixdown(int a[], int i, int n)   
  2. {   
  3.     int j, temp;   
  4.    
  5.     temp = a[i];   
  6.     j = 2 * i + 1;   
  7.     while (j < n)   
  8.     {   
  9.         if (j + 1 < n && a[j + 1] < a[j]) //在左右孩子中找最小的   
  10.             j++;   
  11.    
  12.         if (a[j] >= temp)   
  13.             break;   
  14.    
  15.         a[i] = a[j];     //把较小的子结点往上移动,替换它的父结点   
  16.         i = j;   
  17.         j = 2 * i + 1;   
  18.     }   
  19.     a[i] = temp;   
  20. }   


//在最小堆中删除数 
[cpp] view plain copy
  1. void MinHeapDeleteNumber(int a[], int n)   
  2. {   
  3.     Swap(a[0], a[n - 1]);   
  4.     MinHeapFixdown(a, 0, n - 1);   
  5. }    

堆化数组

有了堆的插入和删除后，再考虑下如何对一个数据进行堆化操作。

写出堆化数组的代码：

//建立最小堆 
[cpp] view plain copy
  1. void MakeMinHeap(int a[], int n)   
  2. {   
  3.     for (int i = n / 2 - 1; i >= 0; i--)   
  4.         MinHeapFixdown(a, i, n);   
  5. }    

至此，堆的操作就全部完成了(注1)，再来看下如何用堆这种数据结构来进行排序。

堆排序

首先可以看到堆建好之后堆中第0个数据是堆中最小的数据。取出这个数据再执行下堆的删除操作。这样堆中第0个数据又是堆中最小的数据，重复上述步骤直至堆中只有一个数据时就直接取出这个数据。

由于堆也是用数组模拟的，故堆化数组后，第一次将A[0]与A[n - 1]交换，再对A[0…n-2]重新恢复堆。第二次将A[0]与A[n – 2]交换，再对A[0…n - 3]重新恢复堆，重复这样的操作直到A[0]与A[1]交换。由于每次都是将最小的数据并入到后面的有序区间，故操作完成后整个数组就有序了。有点类似于直接选择排序。

[cpp] view plain copy
  1. void MinheapsortTodescendarray(int a[], int n)   
  2. {   
  3.     for (int i = n - 1; i >= 1; i--)   
  4.     {   
  5.         Swap(a[i], a[0]);   
  6.         MinHeapFixdown(a, 0, i);   
  7.     }   
  8. }    

注意使用最小堆排序后是递减数组，要得到递增数组，可以使用最大堆。

由于每次重新恢复堆的时间复杂度为O(logN)，共N - 1次重新恢复堆操作，再加上前面建立堆时N / 2次向下调整，每次调整时间复杂度也为O(logN)。二次操作时间相加还是O(N * logN)。故堆排序的时间复杂度为O(N * logN)。STL也实现了堆的相关函数，可以参阅《STL系列之四 heap 堆》。

 

 

注1 作为一个数据结构，最好用类将其数据和方法封装起来，这样即便于操作，也便于理解。此外，除了堆排序要使用堆，另外还有很多场合可以使用堆来方便和高效的处理数据，以后会一一介绍。

转载请标明出处，原文地址：http://blog.csdn.net/morewindows/article/details/6709644


来源： <http://blog.csdn.net/morewindows/article/details/6709644/>
 
再贴一份源码：
Heap Sort

[cpp] view plain copy
  1. //堆筛选函数  
  2. //已知H[start~end]中除了start之外均满足堆的定义  
  3. //本函数进行调整，使H[start~end]成为一个大顶堆  
  4. typedef int ElemType;  
  5. void HeapAdjust(ElemType H[], int start, int end)  
  6. {  
  7.   
  8.     ElemType temp = H[start];  
  9.   
  10.     for(int i = 2*start + 1; i<=end; i*=2)  
  11.     {  
  12.         //因为假设根结点的序号为0而不是1，所以i结点左孩子和右孩子分别为2i+1和2i+2  
  13.         if(i<end && H[i]<H[i+1])//左右孩子的比较  
  14.         {  
  15.             ++i;//i为较大的记录的下标  
  16.         }  
  17.   
  18.         if(temp > H[i])//左右孩子中获胜者与父亲的比较  
  19.         {  
  20.             break;  
  21.         }  
  22.   
  23.         //将孩子结点上位，则以孩子结点的位置进行下一轮的筛选  
  24.         H[start]= H[i];  
  25.         start = i;  
  26.     }  
  27.     H[start]= temp; //插入最开始不和谐的元素  
  28. }  
  29.   
  30. void HeapSort(ElemType A[], int n)  
  31. {  
  32.     //先建立大顶堆  
  33.     for(int i=n/2; i>=0; --i)  
  34.     {  
  35.         HeapAdjust(A,i,n);  
  36.     }  
  37.     //进行排序  
  38.     for(int i=n-1; i>0; --i)  
  39.     {  
  40.         //最后一个元素和第一元素进行交换  
  41.         ElemType temp=A[i];  
  42.         A[i] = A[0];  
  43.         A[0] = temp;  
  44.   
  45.         //然后将剩下的无序元素继续调整为大顶堆  
  46.         HeapAdjust(A,0,i-1);  
  47.     }  
  48. }  


来源：<http://www.cnblogs.com/mengdd/archive/2012/11/30/2796845.html>

归并排序

归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
归并操作的工作原理如下：
  1. 第一步：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
  2. 第二步：设定两个指针，最初位置分别为两个已经排序序列的起始位置
  3. 第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
  4. 重复步骤3直到某一指针超出序列尾
  5. 将另一序列剩下的所有元素直接复制到合并序列尾
代码示例：
[cpp] view plain copy
  1. #define N 8  
  2. void merge(int x[], int low,int mid,int high)        /* 对子序列x[low~mid]和x[mid+1~high]进行归并操作 */  
  3. {  
  4.     int i, j, k;  
  5.     int m, n;  
  6.     int t;  
  7.     int y[N];                                /* 临时缓冲区 */  
  8.     i = low;                                /* 指向前一个子序列的起始位置 */  
  9.     j = mid+1;                             /* 指向后一个子序列的起始位置 */  
  10.     for(k=low; i<=mid&&j<=high; k++)            /* 逐个比较两个子序列中数据元素的大小 */  
  11.     {  
  12.         if(x[i] <= x[j])                         /* 将较小的数据元素放入缓冲区 */  
  13.             y[k] = x[i++];  
  14.         else  
  15.             y[k] = x[j++];  
  16.     }  
  17.       /* 如果前一个子序列中的数据元素已经比较完毕，则直接复制后一个子序列中的数据元素到缓冲区 */  
  18.     if(i <= mid)  
  19.     {  
  20.         for(m=i; m<=mid; m++)  
  21.         {  
  22.             y[k++] = x[m];  
  23.         }  
  24.     }  
  25.       /* 如果后一个子序列中的数据元素已经比较完毕，则直接复制前一个子序列中的数据元素到缓冲区 */  
  26.     if(j <= high)  
  27.     {  
  28.         for(n=j; n<=high; n++)  
  29.         {  
  30.             y[k++] = x[n];  
  31.         }  
  32.     }  
  33.       /* 将缓冲区中的数据元素复制回原序列中 */  
  34.     for (t=low; t<=high; t++)  
  35.     {  
  36.         x[t] = y[t];  
  37.     }  
  38. }  
  39. void me_sort(int x[], int low,int high)            /* 定义归并排序函数，递归方式 */  
  40. {  
  41.     int mid;  
  42.     if(low < high)  
  43.     {  
  44.         mid = (low+high)/2;  
  45.         me_sort(x, low, mid);                 /* 递归调用，将子序列x[low~mid]归并为有序序列 */  
  46.         me_sort(x, mid+1, high);                 /* 递归调用，将子序列x[mid+1~high]归并为有序序列 */  
  47.         merge(x, low,mid,high);                /* 将子序列x[low~mid]和x[mid+1~high]进行归并 */  
  48.     }  
  49. }  



来源： <http://blog.chinaunix.net/uid-24219701-id-144070.html>
再附上一份代码，来自百度知道：
[cpp] view plain copy
  1. #include<stdlib.h>  
  2. #include<stdio.h>  
  3.    
  4. void Merge(int sourceArr[],int tempArr[],int startIndex,int midIndex,int endIndex)  
  5. {  
  6.     int i = startIndex,j=midIndex+1,k = startIndex;  
  7.     while(i!=midIndex+1 && j!=endIndex+1)  
  8.     {  
  9.         if(sourceArr[i]>sourceArr[j])  
  10.             tempArr[k++] = sourceArr[i++];  
  11.         else  
  12.             tempArr[k++] = sourceArr[j++];  
  13.     }  
  14.     while(i!=midIndex+1)  
  15.         tempArr[k++] = sourceArr[i++];  
  16.     while(j!=endIndex+1)  
  17.         tempArr[k++] = sourceArr[j++];  
  18.     for(i=startIndex;i<=endIndex;i++)  
  19.         sourceArr[i] = tempArr[i];  
  20. }  
  21.    
  22. //内部使用递归  
  23. void MergeSort(int sourceArr[],int tempArr[],int startIndex,int endIndex)  
  24. {  
  25.     int midIndex;  
  26.     if(startIndex<endIndex)  
  27.     {  
  28.         midIndex=(startIndex+endIndex)/2;  
  29.         MergeSort(sourceArr,tempArr,startIndex,midIndex);  
  30.         MergeSort(sourceArr,tempArr,midIndex+1,endIndex);  
  31.         Merge(sourceArr,tempArr,startIndex,midIndex,endIndex);  
  32.     }  
  33. }  
  34.    
  35. int main(int argc,char * argv[])  
  36. {  
  37.     int a[8]={50,10,20,30,70,40,80,60};  
  38.     int i,b[8];  
  39.     MergeSort(a,b,0,7);  
  40.     for(i=0;i<8;i++)  
  41.         printf("%d ",a[i]);  
  42.     printf("\n");  
  43.     return 0;  
  44. }  


快速排序

快速排序（Quicksort）是对冒泡排序的一种改进。快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。
一趟快速排序的算法是：
  • 1）设置两个变量i、j，排序开始的时候：i=0，j=N-1；
  • 2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]；
  • 3）从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于key的值A[j]，将A[j]和A[i]互换；
  • 4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]互换；
  • 5）重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。
[cpp] view plain copy
  1. #include <iostream>  
  2. using namespace std;  
  3.    
  4. void Qsort(int a[], int low, int high)  
  5. {  
  6.     if(low >= high)  
  7.     {  
  8.         return;  
  9.     }  
  10.     int first = low;  
  11.     int last = high;  
  12.     int key = a[first];/*用字表的第一个记录作为枢轴*/  
  13.    
  14.     while(first < last)  
  15.     {  
  16.         while(first < last && a[last] >= key)  
  17.         {  
  18.             --last;  
  19.         }  
  20.         a[first] = a[last];/*将比第一个小的移到低端*/  
  21.         while(first < last && a[first] <= key)  
  22.         {  
  23.             ++first;  
  24.         }  
  25.         a[last] = a[first];      
  26.     /*将比第一个大的移到高端*/  
  27.     }  
  28.     a[first] = key;/*枢轴记录到位*/  
  29.     Qsort(a, low, first-1);  
  30.     Qsort(a, first+1, high);  
  31. }  
  32. int main()  
  33. {  
  34.     int a[] = {57, 68, 59, 52, 72, 28, 96, 33, 24};  
  35.     Qsort(a, 0, sizeof(a) / sizeof(a[0]) - 1);/*这里原文第三个参数要减1否则内存泄露*/  
  36.     for(int i = 0; i < sizeof(a) / sizeof(a[0]); i++)  
  37.     {  
  38.         cout << a[i] << "";  
  39.     }  
  40.     return 0;  
  41. }/*参考数据结构p274(清华大学出版社，严蔚敏)*/  


再贴一段代码：

[cpp] view plain copy
  1. void sort(int *a, int left, int right)  
  2. {  
  3.     if(left >= right)/*如果左边的数组大于或者等于就代表已经整理完成一个组了*/  
  4.     {  
  5.         return ;  
  6.     }  
  7.     int i = left;  
  8.     int j = right;  
  9.     int key = a[left];  
  10.        
  11.     while(i < j)                               /*控制在当组内寻找一遍*/  
  12.     {  
  13.         while(i < j && key <= a[j])  
  14.         /*而寻找结束的条件就是，1，找到一个小余或者大于key的数（大小取决于你想升 
  15.         序还是降序）2，没有符合的切i与j相遇*/   
  16.         {  
  17.             j--;/*向前寻找*/  
  18.         }  
  19.            
  20.         a[i] = a[j];  
  21.         /*找到一个这样的数后就把它赋给前面的被拿走的i的值（如果第一次循环且key是 
  22.         a[0]，那么就是给key）*/  
  23.            
  24.         while(i < j && key >= a[i])  
  25.         /*这是i在当组内向前寻找，同上，不过注意与key的大小关系停止循环和上面相反， 
  26.         因为排序思想是把数往两边扔，所以左右两边的数大小与key的关系相反*/  
  27.         {  
  28.             i++;  
  29.         }  
  30.            
  31.         a[j] = a[i];  
  32.     }  
  33.        
  34.     a[i] = key;/*当在当组内找完一遍以后就把中间数key回归*/  
  35.     sort(a, left, i - 1);/*最后用同样的方式对分出来的左边的小组进行同上的做法*/  
  36.     sort(a, i + 1, right);/*用同样的方式对分出来的右边的小组进行同上的做法*/  
  37.                        /*当然最后可能会出现很多分左右，直到每一组的i = j 为止*/  
  38. }  


    排序算法稳定性：

这几天笔试了好几次了，连续碰到一个关于常见排序算法稳定性判别的问题，往往还是多选，对于我以及和我一样拿不准的同学可不是一个能轻易下结论的题目，当然如果你笔试之前已经记住了数据结构书上哪些是稳定的，哪些不是稳定的，做起来应该可以轻松搞定。

本文是针对老是记不住这个或者想真正明白到底为什么是稳定或者不稳定的人准备的。

      首先，排序算法的稳定性大家应该都知道，通俗地讲就是能保证排序前2个相等的数其在序列的前后位置顺序和排序后它们两个的前后位置顺序相同。在简单形式化一下，如果Ai = Aj, Ai原来在位置前，排序后Ai还是要在Aj位置前。

     其次，说一下稳定性的好处。排序算法如果是稳定的，那么从一个键上排序，然后再从另一个键上排序，第一个键排序的结果可以为第二个键排序所用。基数排序就是这样，先按低位排序，逐次按高位排序，低位相同的元素其顺序再高位也相同时是不会改变的。另外，如果排序算法稳定，对基于比较的排序算法而言，元素交换的次数可能会少一些(个人感觉，没有证实)。

     回到主题，现在分析一下常见的排序算法的稳定性，每个都给出简单的理由。

(1)冒泡排序

        冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，我想你是不会再无聊地把他们俩交换一下的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。

(2)选择排序

      选择排序是给每个位置选择当前元素最小的，比如给第一个位置选择最小的，在剩余元素里面给第二个元素选择第二小的，依次类推，直到第n-1个元素，第n个元素不用选择了，因为只剩下它一个最大的元素了。那么，在一趟选择，如果当前元素比一个元素小，而该小的元素又出现在一个和当前元素相等的元素后面，那么交换后稳定性就被破坏了。比较拗口，举个例子，序列5 8 5 2 9， 我们知道第一遍选择第1个元素5会和2交换，那么原序列中2个5的相对前后顺序就被破坏了，所以选择排序不是一个稳定的排序算法。

(3)插入排序
     插入排序是在一个已经有序的小序列的基础上，一次插入一个元素。当然，刚开始这个有序的小序列只有1个元素，就是第一个元素。比较是从有序序列的末尾开始，也就是想要插入的元素和已经有序的最大者开始比起，如果比它大则直接插入在其后面，否则一直往前找直到找到它该插入的位置。如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。

(4)快速排序
    快速排序有两个方向，左边的i下标一直往右走，当a[i] <= a[center_index]，其中center_index是中枢元素的数组下标，一般取为数组第0个元素。而右边的j下标一直往左走，当a[j] > a[center_index]。如果i和j都走不动了，i <= j, 交换a[i]和a[j],重复上面的过程，直到i>j。 交换a[j]和a[center_index]，完成一趟快速排序。在中枢元素和a[j]交换的时候，很有可能把前面的元素的稳定性打乱，比如序列为 5 3 3 4 3 8 9 10 11， 现在中枢元素5和3(第5个元素，下标从1开始计)交换就会把元素3的稳定性打乱，所以快速排序是一个不稳定的排序算法，不稳定发生在中枢元素和a[j]交换的时刻。

(5)归并排序
    归并排序是把序列递归地分成短序列，递归出口是短序列只有1个元素(认为直接有序)或者2个序列(1次比较和交换),然后把各个有序的段序列合并成一个有序的长序列，不断合并直到原序列全部排好序。可以发现，在1个或2个元素时，1个元素不会交换，2个元素如果大小相等也没有人故意交换，这不会破坏稳定性。那么，在短的有序序列合并的过程中，稳定是是否受到破坏？没有，合并过程中我们可以保证如果两个当前元素相等时，我们把处在前面的序列的元素保存在结果序列的前面，这样就保证了稳定性。所以，归并排序也是稳定的排序算法。

(6)基数排序
   基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序，最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以其是稳定的排序算法。

(7)希尔排序(shell)
    希尔排序是按照不同步长对元素进行插入排序，当刚开始元素很无序的时候，步长最大，所以插入排序的元素个数很少，速度很快；当元素基本有序了，步长很小，插入排序对于有序的序列效率很高。所以，希尔排序的时间复杂度会比o(n^2)好一些。由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以shell排序是不稳定的。

(8)堆排序
   我们知道堆的结构是节点i的孩子为2*i和2*i+1节点，大顶堆要求父节点大于等于其2个子节点，小顶堆要求父节点小于等于其2个子节点。在一个长为n的序列，堆排序的过程是从第n/2开始和其子节点共3个值选择最大(大顶堆)或者最小(小顶堆),这3个元素之间的选择当然不会破坏稳定性。但当为n/2-1, n/2-2, ...1这些个父节点选择元素时，就会破坏稳定性。有可能第n/2个父节点交换把后面一个元素交换过去了，而第n/2-1个父节点把后面一个相同的元素没有交换，那么这2个相同的元素之间的稳定性就被破坏了。所以，堆排序不是稳定的排序算法


1 快速排序（QuickSort）
快速排序是一个就地排序，分而治之，大规模递归的算法。从本质上来说，它是归并排序的就地版本。快速排序可以由下面四步组成。
（1） 如果不多于1个数据，直接返回。
（2） 一般选择序列最左边的值作为支点数据。
（3） 将序列分成2部分，一部分都大于支点数据，另外一部分都小于支点数据。
（4） 对两边利用递归排序数列。
快速排序比大部分排序算法都要快。尽管我们可以在某些特殊的情况下写出比快速排序快的算法，但是就通常情况而言，没有比它更快的了。快速排序是递归的，对于内存非常有限的机器来说，它不是一个好的选择。 

2 归并排序（MergeSort）
归并排序先分解要排序的序列，从1分成2，2分成4，依次分解，当分解到只有1个一组的时候，就可以排序这些分组，然后依次合并回原来的序列中，这样就可以排序所有数据。合并排序比堆排序稍微快一点，但是需要比堆排序多一倍的内存空间，因为它需要一个额外的数组。

3 堆排序（HeapSort）
堆排序适合于数据量非常大的场合（百万数据）。

堆排序不需要大量的递归或者多维的暂存数组。这对于数据量非常巨大的序列是合适的。比如超过数百万条记录，因为快速排序，归并排序都使用递归来设计算法，在数据量非常大的时候，可能会发生堆栈溢出错误。

堆排序会将所有的数据建成一个堆，最大的数据在堆顶，然后将堆顶数据和序列的最后一个数据交换。接下来再次重建堆，交换数据，依次下去，就可以排序所有的数据。

4 Shell排序（ShellSort）

Shell排序通过将数据分成不同的组，先对每一组进行排序，然后再对所有的元素进行一次插入排序，以减少数据交换和移动的次数。平均效率是O(nlogn)。其中分组的合理性会对算法产生重要的影响。现在多用D.E.Knuth的分组方法。

Shell排序比冒泡排序快5倍，比插入排序大致快2倍。Shell排序比起QuickSort，MergeSort，HeapSort慢很多。但是它相对比较简单，它适合于数据量在5000以下并且速度并不是特别重要的场合。它对于数据量较小的数列重复排序是非常好的。

5 插入排序（InsertSort）

插入排序通过把序列中的值插入一个已经排序好的序列中，直到该序列的结束。插入排序是对冒泡排序的改进。它比冒泡排序快2倍。一般不用在数据大于1000的场合下使用插入排序，或者重复排序超过200数据项的序列。

6 冒泡排序（BubbleSort）

冒泡排序是最慢的排序算法。在实际运用中它是效率最低的算法。它通过一趟又一趟地比较数组中的每一个元素，使较大的数据下沉，较小的数据上升。它是O(n^2)的算法。

7 交换排序（ExchangeSort）和选择排序（SelectSort）

这两种排序方法都是交换方法的排序算法，效率都是 O(n2)。在实际应用中处于和冒泡排序基本相同的地位。它们只是排序算法发展的初级阶段，在实际中使用较少。

8 基数排序（RadixSort）

基数排序和通常的排序算法并不走同样的路线。它是一种比较新颖的算法，但是它只能用于整数的排序，如果我们要把同样的办法运用到浮点数上，我们必须了解浮点数的存储格式，并通过特殊的方式将浮点数映射到整数上，然后再映射回去，这是非常麻烦的事情，因此，它的使用同样也不多。而且，最重要的是，这样算法也需要较多的存储空间。

9 总结

下面是一个总的表格，大致总结了我们常见的所有的排序算法的特点。

排序法平均时间最差情形稳定度额外空间备注冒泡O(n2)O(n2)稳定O(1)n小时较好交换O(n2)O(n2)不稳定O(1)n小时较好选择O(n2)O(n2)不稳定O(1)n小时较好插入O(n2)O(n2)稳定O(1)大部分已排序时较好基数O(logRB)O(logRB)稳定O(n)

B是真数(0-9)，

R是基数(个十百)

ShellO(nlogn)O(ns) 1<s<2不稳定O(1)s是所选分组快速O(nlogn)O(n2)不稳定O(logn)n大时较好归并O(nlogn)O(nlogn)稳定O(n)n大时较好堆O(nlogn)O(nlogn)不稳定O(1)n大时较好
来源： <http://blog.csdn.net/hkx1n/article/details/3922249>
阅读全文
0 0
剑灵人男捏脸数据截图 剑灵人男捏脸数据截图
原创粉丝点击
热门IT博客
陈震媳妇的淘宝店陈震媳妇的淘宝店
财务会计软件有哪些财务会计软件有哪些
淘宝买沙发靠谱吗
淘宝客服上班时间表
理解linux内核
ubuntu 安装opera卡死
java判断请求的浏览器
网络电视可以上网页吗
阿里云企业邮箱客服
python word2pdf
uuu加速器网络官网
淘宝app首页
ubuntu 16.04与17区别
网络出版许可证查询
网络拓扑图在线制作
mac os x10.11
nga 删淘宝
淘宝网天猫投诉电话
美国eia数据在那里看
mac最好看的粉色
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 黑色狗狗名字 狗狗情侣名字 个性狗狗名字 狗狗可爱名字 适合狗狗的名字 男狗狗的名字 狗狗名字大全英文 女狗狗名字 狗狗取什么名字 狗狗名字公的 狗狗个性名字 可爱的狗狗名字 可爱狗狗名字 华登区块狗 狗带吧青春 m狗吧 狗带吧青春免费阅读 华登区块狗吧 狗带吧青春免费完整版 狗带吧青春李玥干婉儿图片 睡觉吧狗命要紧图片 狗带吧青春txt下载 狗哥 狗哥是谁 我的狗哥 狗啃刘海短发 狗啃式刘海 窦靖童留狗啃式刘海 狗啃刘海图片 狗啃短发 狗啃骨头图片 狗啃短发图片 网红狗啃式刘海短发 综恐这狗啃的人生 二次元狗啃式刘海图片 狗啃式刘海图片 狗啃刘海图片男 2018直短发和狗啃刘海图片 大狗图 狗狗寄养 大狗图片

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里