【转】八大排序算法综合-----》

 

1）-------------------

转自：http://blog.csdn.net/hguisu/article/details/7776068

 

概述排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，

一次不能容纳全部的排序记录，在排序过程中需要访问外存。

我们这里说说八大排序就是内部排序。

    

    当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序序。

   快速排序：是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短；

 

1.插入排序—直接插入排序(Straight Insertion Sort)

基本思想:

将一个记录插入到已排序好的有序表中，从而得到一个新，记录数增1的有序表。即：先将序列的第1个记录看成是一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。

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

直接插入排序示例：

 

如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，

所以插入排序是稳定的。

算法的实现：

void print(int a[], int n ,int i){  
02.    cout<<i <<":";  
03.    for(int j= 0; j<8; j++){  
04.        cout<<a[j] <<" ";  
05.    }  
06.    cout<<endl;  
07.}  
08.  
09.  
10.void InsertSort(int a[], int n)  
11.{  
12.    for(int i= 1; i<n; i++){  
13.        if(a[i] < a[i-1]){               //若第i个元素大于i-1元素，直接插入。小于的话，移动有序表后插入  
14.            int j= i-1;   
15.            int x = a[i];        //复制为哨兵，即存储待排序元素  
16.            a[i] = a[i-1];           //先后移一个元素  
17.            while(x < a[j]){  //查找在有序表的插入位置  
18.                a[j+1] = a[j];  
19.                j--;         //元素后移  
20.            }  
21.            a[j+1] = x;      //插入到正确位置  
22.        }  
23.        print(a,n,i);           //打印每趟排序的结果  
24.    }  
25.      
26.}  
27.  
28.int main(){  
29.    int a[8] = {3,1,5,7,2,4,9,6};  
30.    InsertSort(a,8);  
31.    print(a,8,8);  
32.}  

 

效率：

时间复杂度：O（n^2）.

其他的插入排序有二分插入排序，2-路插入排序。

 

 2. 插入排序—希尔排序（Shell`s Sort）

希尔排序是1959 年由D.L.Shell 提出来的，相对直接排序有较大的改进。希尔排序又叫缩小增量排序

基本思想：

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

操作方法：

1. 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
2. 按增量序列个数k，对序列进行k 趟排序；
3. 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

希尔排序的示例：

 

算法实现：

 

我们简单处理增量序列：增量序列d = {n/2 ,n/4, n/8 .....1} n为要排序数的个数

即：先将要排序的一组记录按某个增量d（n/2,n为要排序数的个数）分成若干组子序列，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。继续不断缩小增量直至为1，最后使用直接插入排序完成排序。

void print(int a[], int n ,int i){  
02.    cout<<i <<":";  
03.    for(int j= 0; j<8; j++){  
04.        cout<<a[j] <<" ";  
05.    }  
06.    cout<<endl;  
07.}  
08./** 
09. * 直接插入排序的一般形式 
10. * 
11. * @param int dk 缩小增量，如果是直接插入排序，dk=1 
12. * 
13. */  
14.  
15.void ShellInsertSort(int a[], int n, int dk)  
16.{  
17.    for(int i= dk; i<n; ++i){  
18.        if(a[i] < a[i-dk]){          //若第i个元素大于i-1元素，直接插入。小于的话，移动有序表后插入  
19.            int j = i-dk;     
20.            int x = a[i];           //复制为哨兵，即存储待排序元素  
21.            a[i] = a[i-dk];         //首先后移一个元素  
22.            while(x < a[j]){     //查找在有序表的插入位置  
23.                a[j+dk] = a[j];  
24.                j -= dk;             //元素后移  
25.            }  
26.            a[j+dk] = x;            //插入到正确位置  
27.        }  
28.        print(a, n,i );  
29.    }  
30.      
31.}  
32.  
33./** 
34. * 先按增量d（n/2,n为要排序数的个数进行希尔排序 
35. * 
36. */  
37.void shellSort(int a[], int n){  
38.  
39.    int dk = n/2;  
40.    while( dk >= 1  ){  
41.        ShellInsertSort(a, n, dk);  
42.        dk = dk/2;  
43.    }  
44.}  
45.int main(){  
46.    int a[8] = {3,1,5,7,2,4,9,6};  
47.    //ShellInsertSort(a,8,1); //直接插入排序  
48.    shellSort(a,8);           //希尔插入排序  
49.    print(a,8,8);  
50.}  

 

 

希尔排序时效分析很难，关键码的比较次数与记录移动次数依赖于增量因子序列d的选取，特定情况下可以准确估算出关键码的比较次数和记录的移动次数。目前还没有人给出选取最好的增量因子序列的方法。增量因子序列可以有各种取法，有取奇数的，也有取质数的，但需要注意：增量因子中除1 外没有公因子，且最后一个增量因子必须为1。希尔排序方法是一个不稳定的排序方法。

 

3. 选择排序—简单选择排序（Simple Selection Sort）

基本思想：

在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数交换；然后在剩下的数当中再找最小（或者最大）的与第2个位置的数交换，依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。

简单选择排序的示例：

 

操作方法：

第一趟，从n 个记录中找出关键码最小的记录与第一个记录交换；

第二趟，从第二个记录开始的n-1 个记录中再选出关键码最小的记录与第二个记录交换；

以此类推.....

第i 趟，则从第i 个记录开始的n-i+1 个记录中选出关键码最小的记录与第i 个记录交换，

直到整个序列按关键码有序。

算法实现：

void print(int a[], int n ,int i){  
02.    cout<<"第"<<i+1 <<"趟 : ";  
03.    for(int j= 0; j<8; j++){  
04.        cout<<a[j] <<"  ";  
05.    }  
06.    cout<<endl;  
07.}  
08./** 
09. * 数组的最小值 
10. * 
11. * @return int 数组的键值 
12. */  
13.int SelectMinKey(int a[], int n, int i)  
14.{  
15.    int k = i;  
16.    for(int j=i+1 ;j< n; ++j) {  
17.        if(a[k] > a[j]) k = j;  
18.    }  
19.    return k;  
20.}  
21.  
22./** 
23. * 选择排序 
24. * 
25. */  
26.void selectSort(int a[], int n){  
27.    int key, tmp;  
28.    for(int i = 0; i< n; ++i) {  
29.        key = SelectMinKey(a, n,i);           //选择最小的元素  
30.        if(key != i){  
31.            tmp = a[i];  a[i] = a[key]; a[key] = tmp; //最小元素与第i位置元素互换  
32.        }  
33.        print(a,  n , i);  
34.    }  
35.}  
36.int main(){  
37.    int a[8] = {3,1,5,7,2,4,9,6};  
38.    cout<<"初始值：";  
39.    for(int j= 0; j<8; j++){  
40.        cout<<a[j] <<"  ";  
41.    }  
42.    cout<<endl<<endl;  
43.    selectSort(a, 8);  
44.    print(a,8,8);  
45.}  

 

 简单选择排序的改进——二元选择排序

简单选择排序，每趟循环只能确定一个元素排序后的定位。我们可以考虑改进为每趟循环确定两个元素（当前趟最大和最小记录）的位置,从而减少排序所需的循环次数。改进后对n个数据进行排序，最多只需进行[n/2]趟循环即可。具体实现如下：

void SelectSort(int r[],int n) {  
02.    int i ,j , min ,max, tmp;  
03.    for (i=1 ;i <= n/2;i++) {    
04.        // 做不超过n/2趟选择排序   
05.        min = i; max = i ; //分别记录最大和最小关键字记录位置  
06.        for (j= i+1; j<= n-i; j++) {  
07.            if (r[j] > r[max]) {   
08.                max = j ; continue ;   
09.            }    
10.            if (r[j]< r[min]) {   
11.                min = j ;   
12.            }     
13.      }    
14.      //该交换操作还可分情况讨论以提高效率  
15.      tmp = r[i-1]; r[i-1] = r[min]; r[min] = tmp;  
16.      tmp = r[n-i]; r[n-i] = r[max]; r[max] = tmp;   
17.  
18.    }   
19.}  

 

4. 选择排序—堆排序（Heap Sort）

堆排序是一种树形选择排序，是对直接选择排序的有效改进。

基本思想：

堆的定义如下：具有n个元素的序列（k1,k2,...,kn),当且仅当满足

时称之为堆。由堆的定义可以看出，堆顶元素（即第一个元素）必为最小项（小顶堆）。 若以一维数组存储一个堆，则堆对应一棵完全二叉树，且所有非叶结点的值均不大于(或不小于)其子女的值，根结点（堆顶元素）的值是最小(或最大)的。如：

（a）大顶堆序列：（96, 83,27,38,11,09)

  (b)  小顶堆序列：（12，36，24，85，47，30，53，91）

 

初始时把要排序的n个数的序列看作是一棵顺序存储的二叉树（一维数组存储二叉树），调整它们的存储序，使之成为一个堆，将堆顶元素输出，得到n 个元素中最小(或最大)的元素，这时堆的根节点的数最小（或者最大）。然后对前面(n-1)个元素重新调整使之成为堆，输出堆顶元素，得到n 个元素中次小(或次大)的元素。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。称这个过程为堆排序。

因此，实现堆排序需解决两个问题： 1. 如何将n 个待排序的数建成堆； 2. 输出堆顶元素后，怎样调整剩余n-1 个元素，使其成为一个新堆。

首先讨论第二个问题：输出堆顶元素后，对剩余n-1元素重新建成堆的调整过程。 调整小顶堆的方法：

1）设有m 个元素的堆，输出堆顶元素后，剩下m-1 个元素。将堆底元素送入堆顶（（最后一个元素与堆顶进行交换），堆被破坏，其原因仅是根结点不满足堆的性质。

2）将根结点与左、右子树中较小元素的进行交换。

3）若与左子树交换：如果左子树堆被破坏，即左子树的根结点不满足堆的性质，则重复方法 （2）.

4）若与右子树交换，如果右子树堆被破坏，即右子树的根结点不满足堆的性质。则重复方法 （2）.

5）继续对不满足堆性质的子树进行上述交换操作，直到叶子结点，堆被建成。

称这个自根结点到叶子结点的调整过程为筛选。如图：

再讨论对n 个元素初始建堆的过程。 建堆方法：对初始序列建堆的过程，就是一个反复进行筛选的过程。

1）n 个结点的完全二叉树，则最后一个结点是第个结点的子树。

2）筛选从第个结点为根的子树开始，该子树成为堆。

3）之后向前依次对各结点为根的子树进行筛选，使之成为堆，直到根结点。

如图建堆初始过程：无序序列：（49，38，65，97，76，13，27，49）                    

          

                             

 

 算法的实现：

从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。

void print(int a[], int n){  
02.    for(int j= 0; j<n; j++){  
03.        cout<<a[j] <<"  ";  
04.    }  
05.    cout<<endl;  
06.}  
07.  
08.  
09.  
10./** 
11. * 已知H[s…m]除了H[s] 外均满足堆的定义 
12. * 调整H[s],使其成为大顶堆.即将对第s个结点为根的子树筛选,  
13. * 
14. * @param H是待调整的堆数组 
15. * @param s是待调整的数组元素的位置 
16. * @param length是数组的长度 
17. * 
18. */  
19.void HeapAdjust(int H[],int s, int length)  
20.{  
21.    int tmp  = H[s];  
22.    int child = 2*s+1; //左孩子结点的位置。(i+1 为当前调整结点的右孩子结点的位置)  
23.    while (child < length) {  
24.        if(child+1 <length && H[child]<H[child+1]) { // 如果右孩子大于左孩子(找到比当前待调整结点大的孩子结点)  
25.            ++child ;  
26.        }  
27.        if(H[s]<H[child]) {  // 如果较大的子结点大于父结点  
28.            H[s] = H[child]; // 那么把较大的子结点往上移动，替换它的父结点  
29.            s = child;       // 重新设置s ,即待调整的下一个结点的位置  
30.            child = 2*s+1;  
31.        }  else {            // 如果当前待调整结点大于它的左右孩子，则不需要调整，直接退出  
32.             break;  
33.        }  
34.        H[s] = tmp;         // 当前待调整的结点放到比其大的孩子结点位置上  
35.    }  
36.    print(H,length);  
37.}  
38.  
39.  
40./** 
41. * 初始堆进行调整 
42. * 将H[0..length-1]建成堆 
43. * 调整完之后第一个元素是序列的最小的元素 
44. */  
45.void BuildingHeap(int H[], int length)  
46.{   
47.    //最后一个有孩子的节点的位置 i=  (length -1) / 2  
48.    for (int i = (length -1) / 2 ; i >= 0; --i)  
49.        HeapAdjust(H,i,length);  
50.}  
51./** 
52. * 堆排序算法 
53. */  
54.void HeapSort(int H[],int length)  
55.{  
56.    //初始堆  
57.    BuildingHeap(H, length);  
58.    //从最后一个元素开始对序列进行调整  
59.    for (int i = length - 1; i > 0; --i)  
60.    {  
61.        //交换堆顶元素H[0]和堆中最后一个元素  
62.        int temp = H[i]; H[i] = H[0]; H[0] = temp;  
63.        //每次交换堆顶元素和堆中最后一个元素之后，都要对堆进行调整  
64.        HeapAdjust(H,0,i);  
65.  }  
66.}   
67.  
68.int main(){  
69.    int H[10] = {3,1,5,7,2,4,9,6,10,8};  
70.    cout<<"初始值：";  
71.    print(H,10);  
72.    HeapSort(H,10);  
73.    //selectSort(a, 8);  
74.    cout<<"结果：";  
75.    print(H,10);  
76.  
77.}  

 

分析:

设树深度为k，。从根到叶的筛选，元素比较次数至多2(k-1)次，交换记录至多k 次。

所以，在建好堆后，排序过程中的筛选次数不超过下式： 

                               

而建堆时的比较次数不超过4n 次，因此堆排序最坏情况下，时间复杂度也为：O(nlogn )。

 

5. 交换排序—冒泡排序（Bubble Sort）

基本思想：

在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

冒泡排序的示例：

 

算法的实现：

 

void bubbleSort(int a[], int n){  
02.    for(int i =0 ; i< n-1; ++i) {  
03.        for(int j = 0; j < n-i-1; ++j) {  
04.            if(a[j] > a[j+1])  
05.            {  
06.                int tmp = a[j] ; a[j] = a[j+1] ;  a[j+1] = tmp;  
07.            }  
08.        }  
09.    }  
10.}  

 

冒泡排序算法的改进

对冒泡排序常见的改进方法是加入一标志性变量exchange，用于标志某一趟排序过程中是否有数据交换，如果进行某一趟排序时并没有进行数据交换，则说明数据已经按要求排列好，可立即结束排序，避免不必要的比较过程。本文再提供以下两种改进算法：

1．设置一标志性变量pos,用于记录每趟排序中最后一次进行交换的位置。由于pos位置之后的记录均已交换到位,故在进行下一趟排序时只要扫描到pos位置即可。

改进后算法如下:

void Bubble_1 ( int r[], int n) {  
02.    int i= n -1;  //初始时,最后位置保持不变  
03.    while ( i> 0) {   
04.        int pos= 0; //每趟开始时,无记录交换  
05.        for (int j= 0; j< i; j++)  
06.            if (r[j]> r[j+1]) {  
07.                pos= j; //记录交换的位置   
08.                int tmp = r[j]; r[j]=r[j+1];r[j+1]=tmp;  
09.            }   
10.        i= pos; //为下一趟排序作准备  
11.     }   
12.}    

 

2．传统冒泡排序中每一趟排序操作只能找到一个最大值或最小值,我们考虑利用在每趟排序中进行正向和反向两遍冒泡的方法一次可以得到两个最终值(最大者和最小者) , 从而使排序趟数几乎减少了一半。

改进后的算法实现为:

void Bubble_2 ( int r[], int n){  
02.    int low = 0;   
03.    int high= n -1; //设置变量的初始值  
04.    int tmp,j;  
05.    while (low < high) {  
06.        for (j= low; j< high; ++j) //正向冒泡,找到最大者  
07.            if (r[j]> r[j+1]) {  
08.                tmp = r[j]; r[j]=r[j+1];r[j+1]=tmp;  
09.            }   
10.        --high;                 //修改high值, 前移一位  
11.        for ( j=high; j>low; --j) //反向冒泡,找到最小者  
12.            if (r[j]<r[j-1]) {  
13.                tmp = r[j]; r[j]=r[j-1];r[j-1]=tmp;  
14.            }  
15.        ++low;                  //修改low值,后移一位  
16.    }   
17.}   

 

6. 交换排序—快速排序（Quick Sort）

基本思想：

1）选择一个基准元素,通常选择第一个元素或者最后一个元素,

2）通过一趟排序讲待排序的记录分割成独立的两部分，其中一部分记录的元素值均比基准元素值小。另一部分记录的 元素值比基准值大。

3）此时基准元素在其排好序后的正确位置

4）然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序。

快速排序的示例：

（a）一趟排序的过程：

（b）排序的全过程

算法的实现：

 递归实现：

void print(int a[], int n){  
02.    for(int j= 0; j<n; j++){  
03.        cout<<a[j] <<"  ";  
04.    }  
05.    cout<<endl;  
06.}  
07.  
08.void swap(int *a, int *b)  
09.{  
10.    int tmp = *a;  
11.    *a = *b;  
12.    *b = tmp;  
13.}  
14.  
15.int partition(int a[], int low, int high)  
16.{  
17.    int privotKey = a[low];                             //基准元素  
18.    while(low < high){                                   //从表的两端交替地向中间扫描  
19.        while(low < high  && a[high] >= privotKey) --high;  //从high 所指位置向前搜索，至多到low+1 位置。将比基准元素小的交换到低端  
20.        swap(&a[low], &a[high]);  
21.        while(low < high  && a[low] <= privotKey ) ++low;  
22.        swap(&a[low], &a[high]);  
23.    }  
24.    print(a,10);  
25.    return low;  
26.}  
27.  
28.  
29.void quickSort(int a[], int low, int high){  
30.    if(low < high){  
31.        int privotLoc = partition(a,  low,  high);  //将表一分为二  
32.        quickSort(a,  low,  privotLoc -1);          //递归对低子表递归排序  
33.        quickSort(a,   privotLoc + 1, high);        //递归对高子表递归排序  
34.    }  
35.}  
36.  
37.int main(){  
38.    int a[10] = {3,1,5,7,2,4,9,6,10,8};  
39.    cout<<"初始值：";  
40.    print(a,10);  
41.    quickSort(a,0,9);  
42.    cout<<"结果：";  
43.    print(a,10);  
44.  
45.}  

 

分析：

快速排序是通常被认为在同数量级（O(nlog2n)）的排序方法中平均性能最好的。但若初始序列按关键码有序或基本有序时，快排序反而蜕化为冒泡排序。为改进之，通常以“三者取中法”来选取基准记录，即将排序区间的两个端点与中点三个记录关键码居中的调整为支点记录。快速排序是一个不稳定的排序方法。

  快速排序的改进

在本改进算法中,只对长度大于k的子序列递归调用快速排序,让原序列基本有序，然后再对整个基本有序序列用插入排序算法排序。实践证明，改进后的算法时间复杂度有所降低，且当k取值为  8 左右时,改进算法的性能最佳。算法思想如下：

void print(int a[], int n){  
02.    for(int j= 0; j<n; j++){  
03.        cout<<a[j] <<"  ";  
04.    }  
05.    cout<<endl;  
06.}  
07.  
08.void swap(int *a, int *b)  
09.{  
10.    int tmp = *a;  
11.    *a = *b;  
12.    *b = tmp;  
13.}  
14.  
15.int partition(int a[], int low, int high)  
16.{  
17.    int privotKey = a[low];                 //基准元素  
18.    while(low < high){                   //从表的两端交替地向中间扫描  
19.        while(low < high  && a[high] >= privotKey) --high; //从high 所指位置向前搜索，至多到low+1 位置。将比基准元素小的交换到低端  
20.        swap(&a[low], &a[high]);  
21.        while(low < high  && a[low] <= privotKey ) ++low;  
22.        swap(&a[low], &a[high]);  
23.    }  
24.    print(a,10);  
25.    return low;  
26.}  
27.  
28.  
29.void qsort_improve(int r[ ],int low,int high, int k){  
30.    if( high -low > k ) { //长度大于k时递归, k为指定的数  
31.        int pivot = partition(r, low, high); // 调用的Partition算法保持不变  
32.        qsort_improve(r, low, pivot - 1,k);  
33.        qsort_improve(r, pivot + 1, high,k);  
34.    }   
35.}   
36.void quickSort(int r[], int n, int k){  
37.    qsort_improve(r,0,n,k);//先调用改进算法Qsort使之基本有序  
38.  
39.    //再用插入排序对基本有序序列排序  
40.    for(int i=1; i<=n;i ++){  
41.        int tmp = r[i];   
42.        int j=i-1;  
43.        while(tmp < r[j]){  
44.            r[j+1]=r[j]; j=j-1;   
45.        }  
46.        r[j+1] = tmp;  
47.    }   
48.  
49.}   
50.  
51.  
52.  
53.int main(){  
54.    int a[10] = {3,1,5,7,2,4,9,6,10,8};  
55.    cout<<"初始值：";  
56.    print(a,10);  
57.    quickSort(a,9,4);  
58.    cout<<"结果：";  
59.    print(a,10);  
60.  
61.}  

 

 

7. 归并排序（Merge Sort）

 

基本思想：

归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

归并排序示例：

 

 

合并方法：

设r[i…n]由两个有序子表r[i…m]和r[m+1…n]组成，两个子表长度分别为n-i +1、n-m。

1. j=m+1；k=i；i=i; //置两个子表的起始下标及辅助数组的起始下标
2. 若i>m 或j>n，转⑷ //其中一个子表已合并完，比较选取结束
3. //选取r[i]和r[j]较小的存入辅助数组rf 如果r[i]<r[j]，rf[k]=r[i]； i++； k++； 转⑵ 否则，rf[k]=r[j]； j++； k++； 转⑵
4. //将尚未处理完的子表中元素存入rf 如果i<=m，将r[i…m]存入rf[k…n] //前一子表非空 如果j<=n ,  将r[j…n] 存入rf[k…n] //后一子表非空
5. 合并结束。

//将r[i…m]和r[m +1 …n]归并到辅助数组rf[i…n]  
02.void Merge(ElemType *r,ElemType *rf, int i, int m, int n)  
03.{  
04.    int j,k;  
05.    for(j=m+1,k=i; i<=m && j <=n ; ++k){  
06.        if(r[j] < r[i]) rf[k] = r[j++];  
07.        else rf[k] = r[i++];  
08.    }  
09.    while(i <= m)  rf[k++] = r[i++];  
10.    while(j <= n)  rf[k++] = r[j++];  
11.}  

 

 

归并的迭代算法

 

1 个元素的表总是有序的。所以对n 个元素的待排序列，每个元素可看成1 个有序子表。对子表两两合并生成n/2个子表，所得子表除最后一个子表长度可能为1 外，其余子表长度均为2。再进行两两合并，直到生成n 个元素按关键码有序的表。

void print(int a[], int n){  
02.    for(int j= 0; j<n; j++){  
03.        cout<<a[j] <<"  ";  
04.    }  
05.    cout<<endl;  
06.}  
07.  
08.//将r[i…m]和r[m +1 …n]归并到辅助数组rf[i…n]  
09.void Merge(ElemType *r,ElemType *rf, int i, int m, int n)  
10.{  
11.    int j,k;  
12.    for(j=m+1,k=i; i<=m && j <=n ; ++k){  
13.        if(r[j] < r[i]) rf[k] = r[j++];  
14.        else rf[k] = r[i++];  
15.    }  
16.    while(i <= m)  rf[k++] = r[i++];  
17.    while(j <= n)  rf[k++] = r[j++];  
18.    print(rf,n+1);  
19.}  
20.  
21.void MergeSort(ElemType *r, ElemType *rf, int lenght)  
22.{   
23.    int len = 1;  
24.    ElemType *q = r ;  
25.    ElemType *tmp ;  
26.    while(len < lenght) {  
27.        int s = len;  
28.        len = 2 * s ;  
29.        int i = 0;  
30.        while(i+ len <lenght){  
31.            Merge(q, rf,  i, i+ s-1, i+ len-1 ); //对等长的两个子表合并  
32.            i = i+ len;  
33.        }  
34.        if(i + s < lenght){  
35.            Merge(q, rf,  i, i+ s -1, lenght -1); //对不等长的两个子表合并  
36.        }  
37.        tmp = q; q = rf; rf = tmp; //交换q,rf，以保证下一趟归并时，仍从q 归并到rf  
38.    }  
39.}  
40.  
41.  
42.int main(){  
43.    int a[10] = {3,1,5,7,2,4,9,6,10,8};  
44.    int b[10];  
45.    MergeSort(a, b, 10);  
46.    print(b,10);  
47.    cout<<"结果：";  
48.    print(a,10);  
49.  
50.}  

 

两路归并的递归算法

void MSort(ElemType *r, ElemType *rf,int s, int t)  
02.{   
03.    ElemType *rf2;  
04.    if(s==t) r[s] = rf[s];  
05.    else  
06.    {   
07.        int m=(s+t)/2;          /*平分*p 表*/  
08.        MSort(r, rf2, s, m);        /*递归地将p[s…m]归并为有序的p2[s…m]*/  
09.        MSort(r, rf2, m+1, t);      /*递归地将p[m+1…t]归并为有序的p2[m+1…t]*/  
10.        Merge(rf2, rf, s, m+1,t);   /*将p2[s…m]和p2[m+1…t]归并到p1[s…t]*/  
11.    }  
12.}  
13.void MergeSort_recursive(ElemType *r, ElemType *rf, int n)  
14.{   /*对顺序表*p 作归并排序*/  
15.    MSort(r, rf,0, n-1);  
16.}  

 

8. 桶排序/基数排序(Radix Sort)

说基数排序之前，我们先说桶排序：

基本思想：是将阵列分到有限数量的桶子里。每个桶子再个别排序（有可能再使用别的排序算法或是以递回方式继续使用桶排序进行排序）。

桶排序是鸽巢排序的一种归纳结果。当要被排序的阵列内的数值是均匀分配的时候，桶排序使用线性时间（Θ（n））。

但桶排序并不是 比较排序，他不受到 O(n log n) 下限的影响。         

简单来说，就是把数据分组，放在一个个的桶中，然后对每个桶里面的在进行排序。  

 

 例如要对大小为[1..1000]范围内的n个整数A[1..n]排序  

 首先，可以把桶设为大小为10的范围，具体而言，设集合B[1]存储[1..10]的整数，集合B[2]存储   (10..20]的整数，……集合B[i]存储(   (i-1)*10,   i*10]的整数，i   =   1,2,..100。总共有  100个桶。  

  然后，对A[1..n]从头到尾扫描一遍，把每个A[i]放入对应的桶B[j]中。  再对这100个桶中每个桶里的数字排序，这时可用冒泡，选择，乃至快排，一般来说任  何排序法都可以。

  最后，依次输出每个桶里面的数字，且每个桶中的数字从小到大输出，这  样就得到所有数字排好序的一个序列了。  

  假设有n个数字，有m个桶，如果数字是平均分布的，则每个桶里面平均有n/m个数字。如果  

  对每个桶中的数字采用快速排序，那么整个算法的复杂度是  

  O(n   +   m   *   n/m*log(n/m))   =   O(n   +   nlogn   -   nlogm)  

  从上式看出，当m接近n的时候，桶排序复杂度接近O(n)  

  当然，以上复杂度的计算是基于输入的n个数字是平均分布这个假设的。这个假设是很强的  ，实际应用中效果并没有这么好。如果所有的数字都落在同一个桶中，那就退化成一般的排序了。  

        前面说的几大排序算法 ，大部分时间复杂度都是O（n2），也有部分排序算法时间复杂度是O(nlogn)。而桶式排序却能实现O（n）的时间复杂度。但桶排序的缺点是：

        1）首先是空间复杂度比较高，需要的额外开销大。排序有两个数组的空间开销，一个存放待排序数组，一个就是所谓的桶，比如待排序值是从0到m-1，那就需要m个桶，这个桶数组就要至少m个空间。

        2）其次待排序的元素都要在一定的范围内等等。

       桶式排序是一种分配排序。分配排序的特定是不需要进行关键码的比较，但前提是要知道待排序列的一些具体情况。

 

分配排序的基本思想：说白了就是进行多次的桶式排序。

基数排序过程无须比较关键字，而是通过“分配”和“收集”过程来实现排序。它们的时间复杂度可达到线性阶：O(n)。

实例:

扑克牌中52 张牌，可按花色和面值分成两个字段，其大小关系为： 花色： 梅花< 方块< 红心< 黑心   面值： 2 < 3 < 4 < 5 < 6 < 7 < 8 < 9 < 10 < J < Q < K < A

若对扑克牌按花色、面值进行升序排序，得到如下序列：

即两张牌，若花色不同，不论面值怎样，花色低的那张牌小于花色高的，只有在同花色情况下，大小关系才由面值的大小确定。这就是多关键码排序。

为得到排序结果，我们讨论两种排序方法。

方法1：先对花色排序，将其分为4 个组，即梅花组、方块组、红心组、黑心组。再对每个组分别按面值进行排序，最后，将4 个组连接起来即可。

方法2：先按13 个面值给出13 个编号组(2 号，3 号，...，A 号)，将牌按面值依次放入对应的编号组，分成13 堆。再按花色给出4 个编号组(梅花、方块、红心、黑心)，将2号组中牌取出分别放入对应花色组，再将3 号组中牌取出分别放入对应花色组，……，这样，4 个花色组中均按面值有序，然后，将4 个花色组依次连接起来即可。

设n 个元素的待排序列包含d 个关键码{k1，k2，…，kd}，则称序列对关键码{k1，k2，…，kd}有序是指：对于序列中任两个记录r[i]和r[j](1≤i≤j≤n)都满足下列有序关系：

                                                              

其中k1 称为最主位关键码，kd 称为最次位关键码     。

 

两种多关键码排序方法：

多关键码排序按照从最主位关键码到最次位关键码或从最次位到最主位关键码的顺序逐次排序，分两种方法：

最高位优先(Most Significant Digit first)法，简称MSD 法：

1）先按k1 排序分组，将序列分成若干子序列，同一组序列的记录中，关键码k1 相等。

2）再对各组按k2 排序分成子组，之后，对后面的关键码继续这样的排序分组，直到按最次位关键码kd 对各子组排序后。

3）再将各组连接起来，便得到一个有序序列。扑克牌按花色、面值排序中介绍的方法一即是MSD 法。

最低位优先(Least Significant Digit first)法，简称LSD 法：

1) 先从kd 开始排序，再对kd-1进行排序，依次重复，直到按k1排序分组分成最小的子序列后。

2) 最后将各个子序列连接起来，便可得到一个有序的序列, 扑克牌按花色、面值排序中介绍的方法二即是LSD 法。

 

基于LSD方法的链式基数排序的基本思想

　　“多关键字排序”的思想实现“单关键字排序”。对数字型或字符型的单关键字，可以看作由多个数位或多个字符构成的多关键字，此时可以采用“分配-收集”的方法进行排序，这一过程称作基数排序法，其中每个数字或字符可能的取值个数称为基数。比如，扑克牌的花色基数为4，面值基数为13。在整理扑克牌时，既可以先按花色整理，也可以先按面值整理。按花色整理时，先按红、黑、方、花的顺序分成4摞（分配），再按此顺序再叠放在一起（收集），然后按面值的顺序分成13摞（分配），再按此顺序叠放在一起（收集），如此进行二次分配和收集即可将扑克牌排列有序。   

基数排序:

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

算法实现：

Void RadixSort(Node L[],length,maxradix)  
02.{  
03.   int m,n,k,lsp;  
04.   k=1;m=1;  
05.   int temp[10][length-1];  
06.   Empty(temp); //清空临时空间  
07.   while(k<maxradix) //遍历所有关键字  
08.   {  
09.     for(int i=0;i<length;i++) //分配过程  
10.    {  
11.       if(L[i]<m)  
12.          Temp[0][n]=L[i];  
13.       else  
14.          Lsp=(L[i]/m)%10; //确定关键字  
15.       Temp[lsp][n]=L[i];  
16.       n++;  
17.   }  
18.   CollectElement(L,Temp); //收集  
19.   n=0;  
20.   m=m*10;  
21.  k++;  
22. }  
23.}  

 

 

 

 

 

总结

各种排序的稳定性，时间复杂度和空间复杂度总结：

 我们比较时间复杂度函数的情况：

 

                             时间复杂度函数O(n)的增长情况

所以对n较大的排序记录。一般的选择都是时间复杂度为O(nlog2n)的排序方法。

 

时间复杂度来说：

(1)平方阶(O(n²))排序 　　各类简单排序:直接插入、直接选择和冒泡排序；

 (2)线性对数阶(O(nlog2n))排序 　　快速排序、堆排序和归并排序；

 (3)O(n^1+§))排序,§是介于0和1之间的常数。

       希尔排序 (4)线性阶(O(n))排序 　　基数排序，此外还有桶、箱排序。

说明：

当原表有序或基本有序时，直接插入排序和冒泡排序将大大减少比较次数和移动记录的次数，时间复杂度可降至O（n）；

而快速排序则相反，当原表基本有序时，将蜕化为冒泡排序，时间复杂度提高为O（n2）；

原表是否有序，对简单选择排序、堆排序、归并排序和基数排序的时间复杂度影响不大。

 

稳定性：

排序算法的稳定性:若待排序的序列中，存在多个具有相同关键字的记录，经过排序， 这些记录的相对次序保持不变，则称该算法是稳定的；若经排序后，记录的相对 次序发生了改变，则称该算法是不稳定的。    

   稳定性的好处：排序算法如果是稳定的，那么从一个键上排序，然后再从另一个键上排序，第一个键排序的结果可以为第二个键排序所用。基数排序就是这样，先按低位排序，逐次按高位排序，低位相同的元素其顺序再高位也相同时是不会改变的。另外，如果排序算法稳定，可以避免多余的比较；

稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序

不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序

 

选择排序算法准则：

每种排序算法都各有优缺点。因此，在实用时需根据不同情况适当选用，甚至可以将多种方法结合起来使用。

选择排序算法的依据

影响排序的因素有很多，平均时间复杂度低的算法并不一定就是最优的。相反，有时平均时间复杂度高的算法可能更适合某些特殊情况。同时，选择算法时还得考虑它的可读性，以利于软件的维护。一般而言，需要考虑的因素有以下四点：

1．待排序的记录数目n的大小；

2．记录本身数据量的大小，也就是记录中除关键字外的其他信息量的大小；

3．关键字的结构及其分布情况；

4．对排序稳定性的要求。

设待排序元素的个数为n.

1）当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序序。

   快速排序：是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短；    

   堆排序 ：  如果内存空间允许且要求稳定性的，

    归并排序：它有一定数量的数据移动，所以我们可能过与插入排序组合，先获得一定长度的序列，然后再合并，在效率上将有所提高。

2）  当n较大，内存空间允许，且要求稳定性 =》归并排序

3）当n较小，可采用直接插入或直接选择排序。

    直接插入排序：当元素分布有序，直接插入排序将大大减少比较次数和移动记录的次数。

    直接选择排序 ：元素分布有序，如果不要求稳定性，选择直接选择排序

5）一般不使用或不直接使用传统的冒泡排序。

6）基数排序 它是一种稳定的排序算法，但有一定的局限性： 　

　1、关键字可分解。 　

　2、记录的关键字位数较少，如果密集更好 　

　3、如果是数字时，最好是无符号的，否则将增加相应的映射复杂度，可先将其正负分开排序。

 

 

===================================================================================================================

 

2）-------------------

 

转自：http://www.cnblogs.com/v-July-v/archive/2011/01/04/1983697.html

 

一、快速排序算法的基本特性

时间复杂度：O（n*lgn）

最坏：O（n^2）

空间复杂度：O（n*lgn）

不稳定。

 

快速排序是一种排序算法，对包含n个数的输入数组，平均时间为O（nlgn），最坏情况是O（n^2）。

通常是用于排序的最佳选择。因为，排序最快，也只能达到O（nlgn）。

二、快速排序算法的描述

算法导论，第7章

快速排序时基于分治模式处理的， 对一个典型子数组A[p...r]排序的分治过程为三个步骤：

1.分解： A[p..r]被划分为俩个（可能空）的子数组A[p ..q-1]和A[q+1 ..r]，使得 A[p ..q-1] <= A[q] <= A[q+1 ..r]

2.解决：通过递归调用快速排序，对子数组A[p ..q-1]和A[q+1 ..r]排序。

3.合并。

 

三、快速排序算法

版本一：

QUICKSORT(A, p, r)

1 if p < r

2    then q ← PARTITION(A, p, r)   //关键

3         QUICKSORT(A, p, q - 1)

4         QUICKSORT(A, q + 1, r)

数组划分

快速排序算法的关键是PARTITION过程，它对A[p..r]进行就地重排：

PARTITION(A, p, r)

1  x ← A[r]

2  i ← p - 1

3  for j ← p to r - 1

4       do if A[j] ≤ x

5             then i ← i + 1

6                  exchange A[i] <-> A[j]

7  exchange A[i + 1] <-> A[r]

8  return i + 1

 

ok，咱们来举一个具体而完整的例子。

来对以下数组，进行快速排序，   2   8   7   1   3   5   6   4(主元)

一、

i p/j

  2   8   7   1   3   5   6   4(主元)

j指的2<=4，于是i++，i也指到2，2和2互换，原数组不变。

j后移，直到指向1..

二、          

     j（指向1）<=4，于是i++ i指向了8，所以8与1交换。 数组变成了：  

      i         j   2   1   7   8   3   5   6   4

三、j后移，指向了3,3<=4，于是i++ i这是指向了7，于是7与3交换。 数组变成了：             i         j   2   1   3   8   7   5   6   4

四、j继续后移，发现没有再比4小的数，所以，执行到了最后一步， 即上述PARTITION(A, p, r)代码部分的 第7行。

因此，i后移一个单位，指向了8           

       i              j   2   1   3   8   7   5   6   4 A[i + 1] <-> A[r]，即8与4交换，所以，数组最终变成了如下形式，  

2   1   3   4   7   5   6   8

ok，快速排序第一趟完成。

4把整个数组分成了俩部分，2 1 3,7 5 6 8，再递归对这俩部分分别快速排序。

i p/j  

2   1   3(主元)  

2与2互换，不变，然后又是1与1互换，还是不变，最后，3与3互换，不变，

最终，3把2 1 3，分成了俩部分，2 1，和3. 再对2 1，递归排序，最终结果成为了1 2 3.

7 5 6 8(主元)，7、5、6、都比8小，所以第一趟，还是7 5 6 8， 不过，此刻8把7 5 6 8，分成了  7 5 6，和8.[7 5 6->5 7 6->5 6 7] 再对7 5 6，递归排序，最终结果变成5 6 7 8。

ok，所有过程，全部分析完成。

最后，看下我画的图：

 

快速排序算法版本二

不过，这个版本不再选取（如上第一版本的）数组的最后一个元素为主元，

而是选择，数组中的第一个元素为主元。

/**************************************************/

/*  函数功能：快速排序算法                        */

/*  函数参数：结构类型table的指针变量tab          */

/*            整型变量left和right左右边界的下标   */

/*  函数返回值：空                                */

/*  文件名：quicsort.c  函数名：quicksort ()      */

/**************************************************/

void quicksort(table *tab,int left,int right)

{  

int i,j;

  if(left<right)  {    

i=left;

j=right;

    tab->r[0]=tab->r[i]; //准备以本次最左边的元素值为标准进行划分，先保存其值

    do    

{     

  while(tab->r[j].key>tab->r[0].key&&i<j)     

    j--;        //从右向左找第1个小于标准值的位置j    

   if(i<j)                               //找到了，位置为j    

   {     

    tab->r[i].key=tab->r[j].key;i++;    

   }           //将第j个元素置于左端并重置i    

   while(tab->r[i].key<tab->r[0].key&&i<j)      

   i++;      //从左向右找第1个大于标准值的位置i     

  if(i<j)                       //找到了，位置为i   

    {         tab->r[j].key=tab->r[i].key;j--;    

   }           //将第i个元素置于右端并重置j    

}while(i!=j);

    tab->r[i]=tab->r[0];         //将标准值放入它的最终位置,本次划分结束  

   quicksort(tab,left,i-1);     //对标准值左半部递归调用本函数    

quicksort(tab,i+1,right);    //对标准值右半部递归调用本函数   } }

----------------

ok，咱们，还是以上述相同的数组，应用此快排算法的版本二，来演示此排序过程：

这次，以数组中的第一个元素2为主元。  

2(主)  8  7  1  3  5  6  4

请细看：  

2  8  7  1  3  5  6  4  

i->                     <-j   

(找大)               (找小)

一、j

j找第一个小于2的元素1,1赋给(覆盖重置)i所指元素2 得到：

  1  8  7     3  5  6  4   

    i       j          

  二、i

i找到第一个大于2的元素8,8赋给(覆盖重置)j所指元素(NULL<-8)  

1     7  8  3  5  6  4   

   i   <-j

三、j

j继续左移，在与i碰头之前，没有找到比2小的元素，结束。 最后，主元2补上。

第一趟快排结束之后，数组变成：

  1  2  7  8  3  5  6  4

第二趟，   

      7  8  3  5  6  4     

    i->             <-j      

    (找大)        (找小)  

一、j

j找到4，比主元7小，4赋给7所处位置 得到：   

      4  8  3  5  6      

     i->                j

二、i

i找比7大的第一个元素8,8覆盖j所指元素(NULL)      

   4     3  5  6  8         

    i          j       

  4  6  3  5     8        

     i->       j              

    i与j碰头，结束。

第三趟：      

   4  6  3  5  7  8 ...... 以下，分析原理，一致，略过。

最后的结果，如下图所示：

  1  2  3  4  5  6  7  8

相信，经过以上内容的具体分析，你一定明了了。

最后，贴一下我画的关于这个排序过程的图： 

  

完。一月五日补充。 OK,上述俩种算法，明白一种即可。 -------------------------------------------------------------

 

五、快速排序的最坏情况和最快情况。 最坏情况发生在划分过程产生的俩个区域分别包含n-1个元素和一个0元素的时候， 即假设算法每一次递归调用过程中都出现了，这种划分不对称。那么划分的代价为O（n）， 因为对一个大小为0的数组递归调用后，返回T（0）=O（1）。 估算法的运行时间可以递归的表示为：

    T（n）=T（n-1）+T（0）+O（n)=T(n-1)+O(n). 可以证明为T（n）=O（n^2）。

因此，如果在算法的每一层递归上，划分都是最大程度不对称的，那么算法的运行时间就是O（n^2）。 亦即，快速排序算法的最坏情况并不比插入排序的更好。

此外，当数组完全排好序之后，快速排序的运行时间为O（n^2）。 而在同样情况下，插入排序的运行时间为O（n）。

//注，请注意理解这句话。我们说一个排序的时间复杂度，是仅仅针对一个元素的。 //意思是，把一个元素进行插入排序，即把它插入到有序的序列里，花的时间为n。

  再来证明，最快情况下，即PARTITION可能做的最平衡的划分中，得到的每个子问题都不能大于n/2. 因为其中一个子问题的大小为|_n/2_|。另一个子问题的大小为|-n/2-|-1. 在这种情况下，快速排序的速度要快得多。为，       T(n)<=2T（n/2）+O（n）.可以证得，T（n）=O（nlgn）。

直观上，看，快速排序就是一颗递归数，其中，PARTITION总是产生9:1的划分， 总的运行时间为O（nlgn）。各结点中示出了子问题的规模。每一层的代价在右边显示。 每一层包含一个常数c。

完。 July、二零一一年一月四日。 =============================================

请各位自行，思考以下这个版本，对应于上文哪个版本?  

    HOARE-PARTITION(A, p, r)  

1  x ← A[p]

 2  i ← p - 1  

3  j ← r + 1

 4  while TRUE

 5      do repeat j ← j - 1  

6           until A[j] ≤ x  

7         repeat i ← i + 1  

8           until A[i] ≥ x

 9         if i < j

10            then exchange A[i] ↔ A[j] 11    

        else return j

 

   我常常思考，为什么有的人当时明明读懂明白了一个算法， 而一段时间过后，它又对此算法完全陌生而不了解了列?

   我想，究其根本，还是没有彻底明白此快速排序算法的原理，与来龙去脉... 那作何改进列，只能找发明那个算法的原作者了，从原作者身上，再多挖掘点有用的东西出来。

        July、二零一一年二月十五日更新。

========================================= 最后，再给出一个快速排序算法的简洁示例：

    Quicksort函数

void quicksort(int l, int u)

{  

int i, m;  

   if (l >= u)

return;   

  swap(l, randint(l, u));   

  m = l;   

  for (i = l+1; i <= u; i++)    

     if (x[i] < x[l])      

       swap(++m, i);

    swap(l, m);   

  quicksort(l, m-1);    

quicksort(m+1, u);

}

   如果函数的调用形式是quicksort(0, n-1)，那么这段代码将对一个全局数组x[n]进行排序。 函数的两个参数分别是将要进行排序的子数组的下标：l是较低的下标，而u是较高的下标。

   函数调用swap(i,j)将会交换x[i]与x[j]这两个元素。 第一次交换操作将会按照均匀分布的方式在l和u之间随机地选择一个划分元素。