总结一些排序算法的原理和实现

这两天看了一下常用的排序算法，并进行了简单的实现。

其原理和实现总结如下：

 

简介：

    排序是数据处理中经常使用的一种重要运算，并且排序本身对推动算法分析的发展也起很大作用。

    1、插入排序（直接插入排序、折半插入排序、希尔排序）；
    2、交换排序（起泡排序、快速排序）；
    3、选择排序（直接选择排序、堆排序）；
    4、归并排序；
    5、基数排序；

 

一.直接插入排序

    1．直接插入排序的基本思想 
            直接插入排序（Straight Insertion Sorting）的基本思想是：把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，将它插入到有序表中的适当位置，使之成为新的有序表，重复n-1次可完成排序过程。

    2.算法实现：

1. #include<iostream>
3. using namespace std;
5. void insertSort(int a[], int n)
6. {
7.     int i, j;
8.     int t;  
9.     for(i = 1; i < n; i++)
10.     {
11.         t = a[i];
12.         j = i - 1;
13.         while((j >= 0)&&(t < a[j])) 
14.         {
15.             a[j + 1] = a[j];
16.             j--;    
17.         }
18.         a[j + 1] = t;
19.     }
20. }
23. int main()
24. {
25.     int a[5] = {5,4,2,8,6}; 
26.     insertSort(a, 5);
27.     for(int k = 0; k < 5; k++)
28.     {
29.         cout<<a[k]<<" "<<endl;  
30.     }
31.     return 0;
32. }

    3.效率

        (1).直接插入排序的时间复杂度为O（n2）。

        (2).首先从空间来看，它只需要一个元素的辅助空间，用于元素的位置交换O(1)

        (3).插入排序是稳定的,因为具有同一值的元素必然插在具有同一值得前一个元素的后面,即相对次序不变.           

        (4).插入排序是一种简单的排序方法,他不仅适用于顺序存储结构(数组),而且适用于链接存储结构,不过在链接存储结构上进行直接插入排序时,不用移动元素的位置,而是修改相应的指针。

 

二.冒泡排序

 

    1.冒泡排序的基本思想

        设待排序n个元素存放在数组a[n]中,无序区范围初始为(a(0),a(1),a(2),...,a[n-1]),冒泡排序方法是在当前无序区内,从最上面的元素a[0]开始,对每两个相邻的元素a[i+1]和a[i](i=0,1,...,n-1)进行比较,且使值较小的元素换至值较大的元素之上(若a[i]>a[i+1],则a[i]和a[i+1]的值互换),这样经过一趟冒泡排序后,假设最后下移的元素为a[k],则无序区中值较大的几个元素到达下端并从小到大依次存放在a[k+1],a[k+2],...a[n-1]中,这样无序区范围变为(a[0],a[1],a[2],...,a[k])。在当前无序区内进行下一趟冒泡排序。这个过程一直到某一趟排序中不出现元素交换的动作，排序结束。整个排序过程最多执行n-1遍。这种排序方法是通过相邻元素之间的比较与交换，使值较小的元素逐渐从后部移向前部（从下标较大的单元移向下标较小的单元），就象水底下的气泡一样逐渐向上冒。

    2.排序方法

        将被排序的记录数组R[1..n]垂直排列，每个记录R[i]看作是重量为R[i].key的气泡。根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R：凡扫描到违反本原则的轻气泡，就使其向上"飘浮"。如此反复进行，直到最后任何两个气泡都是轻者在上，重者在下为止。
        （1）初始
　        R[1..n]为无序区。

        （2）第一趟扫描
　        从无序区底部向上依次比较相邻的两个气泡的重量，若发现轻者在下、重者在上，则交换二者的位置。即依次比较(R[n]，R[n-1])，(R[n-1]，R[n-2])，…，(R[2]，R[1])；对于每对气泡(R[j+1]，R[j])，若R[j+1].key<R[j].key，则交换R[j+1]和R[j]的内容。
    　    第一趟扫描完毕时，"最轻"的气泡就飘浮到该区间的顶部，即关键字最小的记录被放在最高位置R[1]上。

        （3）第二趟扫描
　        扫描R[2..n]。扫描完毕时，"次轻"的气泡飘浮到R[2]的位置上……
    　    最后，经过n-1 趟扫描可得到有序区R[1..n]
          注意：
　        第i趟扫描时，R[1..i-1]和R[i..n]分别为当前的有序区和无序区。扫描仍是从无序区底部向上直至该区顶部。扫描完毕时，该区中最轻气泡飘浮到顶部位置R[i]上，结果是R[1..i]变为新的有序区。

     

    3.算法实现

1. #include<iostream>
3. using namespace std;
5. void BubbleSort(int a[], int n)
6. {
7.     int i, j;
8.     bool exchange;
9.     for(i = 0; i < n; i++)
10.     {       
11.         for(j = n - 1; j >= i; j--)//对当前无序区域R[i...n]自下向上扫描
12.         {
13.             if(a[j + 1] < a[j])
14.             {
15.                 int tem;
16.                 tem = a[j + 1];
17.                 a[j + 1] = a[j];
18.                 a[j] = tem;         
19.             }   
20.         }   
21.     }   
22. }
24. int main()
25. {
26.     int a[10] = {10,2,36,12,1,25,42,13,21,11};
27.     BubbleSort(a, 10);
28.     for(int k = 0; k < 10; k++)
29.     {
30.         cout<<a[k]<<" ";    
31.     }   
32.     cout<<endl;
33.     return 0;
34. }

    4.算法分析

        （1）算法的最好时间复杂度
    　    若文件的初始状态是正序的，一趟扫描即可完成排序。所需的关键字比较次数C和记录移动次数M均达到最小值：
            C_min=n-1
            M_min=0。
    　    冒泡排序最好的时间复杂度为O(n)。

        （2）算法的最坏时间复杂度
    　    若初始文件是反序的，需要进行n-1趟排序。每趟排序要进行n-i次关键字的比较(1≤i≤n-1)，且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下，比较和移动次数均达到最大值：
            C_max=n(n-1)/2=O(n²)
            M_max=3n(n-1)/2=O(n²)
    　    冒泡排序的最坏时间复杂度为O(n²)。

        （3）算法的平均时间复杂度为O(n²)
    　    虽然冒泡排序不一定要进行n-1趟，但由于它的记录移动次数较多，故平均时间性能比直接插入排序要差得多。

        （4）算法稳定性
    　    冒泡排序是就地排序，且它是稳定的。

 

三.直接选择排序

    1、直接选择排序的基本思想
   　 n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果：
         ①初始状态：无序区为R[1..n]，有序区为空。
         ②第1趟排序
    　    在无序区R[1..n]中选出关键字最小的记录R[k]，将它与无序区的第1个记录R[1]交换，使R[1..1]和R[2..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。
　　    ……
         ③第i趟排序
　　    第i趟排序开始时，当前有序区和无序区分别为R[1..i-1]和R[i..n](1≤i≤n-1)。该趟排序从当前无序区中选出关键字最小的记录R[k]，将它与无序区的第1个记录R[i]交换，使R[1..i]和R[i+1..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。
    　    这样，n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果。

    2.算法实现      

1. #include<iostream>
3. using namespace std;
5. void SelectionSort(int R[], int n)
6. {
7.     int i, j, k;
8.     for(i = 0; i < n; i++)
9.     {
10.         k =i;
11.         for(j = i + 1; j < n; j++)  
12.         {
13.             if(R[j] < R[k])
14.             {
15.                 k = j;  
16.             }           
17.         }
18.         if(k != i)
19.         {
20.             int tem = R[i];
21.             R[i] = R[k];
22.             R[k] = tem; 
23.         }
24.     }
25. }
27. int main()
28. {
29.     int a[10] = {10,2,36,12,1,25,42,13,21,11};
30.     SelectionSort(a, 10);
31.     for(int m = 0; m < 10; m++)
32.     {
33.         cout<<a[m]<<" ";    
34.     }   
35.     cout<<endl;
36.     return 0;
37. }

    3.算法分析
        （1）关键字比较次数
    　    无论文件初始状态如何，在第i趟排序中选出最小关键字的记录，需做n-i次比较，因此，总的比较次数为：
             n(n-1)/2=0(n²)

        （2）记录的移动次数
    　    当初始文件为正序时，移动次数为0
    　    文件初态为反序时，每趟排序均要执行交换操作，总的移动次数取最大值3(n-1)。
    　    直接选择排序的平均时间复杂度为O(n²)。

        （3）直接选择排序是一个就地排序

        （4）稳定性分析
    　    直接选择排序是不稳定的
     
四.快速排序

 

 

    1.算法思想

        采用了一种分治的策略，通常称其为分治法

        （1） 分治法的基本思想
    　    分治法的基本思想是：将原问题分解为若干个规模更小但结构与原问题相似的子问题。递归地解这些子问题，然后将这些子问题的解组合为原问题的解。

        （2）快速排序的基本思想
    　    设当前待排序的无序区为R[low..high]，利用分治法可将快速排序的基本思想描述为：
            ①分解：
    　        在R[low..high]中任选一个记录作为基准(Pivot)，以此基准将当前无序区划分为左、右两个较小的子区间R[low..pivotpos-1)和R[pivotpos+1..high]，并使左边子区间中所有记录的关键字均小于等于基准记录(不妨记为pivot)的关键字pivot.key，右边的子区间中所有记录的关键字均大于等于pivot.key，而基准记录pivot则位于正确的位置(pivotpos)上，它无须参加后续的排序。
                 注意：
    　        划分的关键是要求出基准记录所在的位置pivotpos。划分的结果可以简单地表示为(注意pivot=R[pivotpos])：
    　        R[low..pivotpos-1].keys≤R[pivotpos].key≤R[pivotpos+1..high].keys
                  其中low≤pivotpos≤high。
            ②求解：
   　         通过递归调用快速排序对左、右子区间R[low..pivotpos-1]和R[pivotpos+1..high]快速排序。
            ③组合：
    　        因为当"求解"步骤中的两个递归调用结束时，其左、右两个子区间已有序。对快速排序而言，"组合"步骤无须做什么，可看作是空操作。
    2、快速排序算法

1. #include<iostream>
3. using namespace std;
5. int Partition(int R[], int i, int j)
6. {
7.     int pivot = R[i];
8.     while(i < j)
9.     {
10.         while(i < j && R[j] >= pivot)
11.         {
12.             j--;    
13.         }
14.         if(i < j)
15.         {
16.             R[i++] = R[j];  
17.         }
18.         while(i < j && R[i] <= pivot)
19.         {
20.             i++;    
21.         }
22.         if(i < j)
23.         {
24.             R[j--] = R[i];  
25.         }
26.     }
27.     R[i] = pivot;
28.     return i;
29. }
31. void QuickSort(int R[], int low, int high)
32. {
33.     int pivotpos;//划分后的基准记录的位置
34.     if(low < high)
35.     {
36.         pivotpos = Partition(R, low, high);//对R[low..high]做划分
37.         QuickSort(R, low, pivotpos - 1);
38.         QuickSort(R, pivotpos + 1, high);
39.     }
40. }
42. int main()
43. {
44.     int a[10] = {10,2,36,12,1,25,42,13,21,11};
45.     QuickSort(a, 0, 9);
46.     for(int m = 0; m < 10; m++)
47.     {
48.         cout<<a[m]<<" ";    
49.     }   
50.     cout<<endl;
51.     return 0;
52. }

    3.算法分析
    　快速排序的时间主要耗费在划分操作上，对长度为k的区间进行划分，共需k-1次关键字的比较。

        （1）最坏时间复杂度
    　    最坏情况是每次划分选取的基准都是当前无序区中关键字最小(或最大)的记录，划分的结果是基准左边的子区间为空(或右边的子区间为空)，而划分所得的另一个非空的子区间中记录数目，仅仅比划分前的无序区中记录个数减少一个。
    　    因此，快速排序必须做n-1次划分，第i次划分开始时区间长度为n-i+1，所需的比较次数为n-i(1≤i≤n-1)，故总的比较次数达到最大值：
               C_max = n(n-1)/2=O(n²)
    　    如果按上面给出的划分算法，每次取当前无序区的第1个记录为基准，那么当文件的记录已按递增序(或递减序)排列时，每次划分所取的基准就是当前无序区中关键字最小(或最大)的记录，则快速排序所需的比较次数反而最多。

        （2） 最好时间复杂度
    　    在最好情况下，每次划分所取的基准都是当前无序区的"中值"记录，划分的结果是基准的左、右两个无序子区间的长度大致相等。总的关键字比较次数：
            0(nlgn)
        注意：
    　    用递归树来分析最好情况下的比较次数更简单。因为每次划分后左、右子区间长度大致相等，故递归树的高度为O(lgn)，而递归树每一层上各结点所对应的划分过程中所需要的关键字比较次数总和不超过n，故整个排序过程所需要的关键字比较总次数C(n)=O(nlgn)。
    　    因为快速排序的记录移动次数不大于比较的次数，所以快速排序的最坏时间复杂度应为0(n²)，最好时间复杂度为O(nlgn)。

        （3）基准关键字的选取
    　    在当前无序区中选取划分的基准关键字是决定算法性能的关键。
　　    ①"三者取中"的规则
    　    "三者取中"规则，即在当前区间里，将该区间首、尾和中间位置上的关键字比较，取三者之中值所对应的记录作为基准，在划分开始前将该基准记录和该区伺的第1个记录进行交换，此后的划分过程与上面所给的Partition算法完全相同。

　　    ②取位于low和high之间的随机数k(low≤k≤high)，用R[k]作为基准
    　    选取基准最好的方法是用一个随机函数产生一个取位于low和high之间的随机数k(low≤k≤high)，用R[k]作为基准，这相当于强迫R[low..high]中的记录是随机分布的。用此方法所得到的快速排序一般称为随机的快速排序。具体算法【参见教材】
        注意：
　        随机化的快速排序与一般的快速排序算法差别很小。但随机化后，算法的性能大大地提高了，尤其是对初始有序的文件，一般不可能导致最坏情况的发生。算法的随机化不仅仅适用于快速排序，也适用于其它需要数据随机分布的算法。

        （4）平均时间复杂度
    　    尽管快速排序的最坏时间为O(n²)，但就平均性能而言，它是基于关键字比较的内部排序算法中速度最快者，快速排序亦因此而得名。它的平均时间复杂度为O(nlgn)。

        （5）空间复杂度
    　    快速排序在系统内部需要一个栈来实现递归。若每次划分较为均匀，则其递归树的高度为O(lgn)，故递归后需栈空间为O(lgn)。最坏情况下，递归树的高度为O(n)，所需的栈空间为O(n)。

        （6）稳定性
    　    快速排序是非稳定的

 

 

五.希尔排序

 

    希尔排序(Shell Sort)是插入排序的一种

    1.基本思想 
        希尔排序（Shell Sort）又称为“缩小增量排序”。是1959年由D.L.Shell提出来的。该方法的基本思想是：先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。因为直接插入排序在元素基本有序的情况下（接近最好情况），效率是很高的，因此希尔排序在时间效率上比前两种方法有较大提高。
具体做法：首先确定一组增量d0，d1，d2，d3，...,dt-1()其中n>d0>d1>...>dt-1=1),对于i=0,1,2,...,t-1,依次进行下面的各趟处理:根据当前增量di将n个元素分成di个组,每组中元素的下标相隔为di;再对各组中元素进行直接插入排序.
        2、下面给出希尔排序算法的执行过程。

            （1）采用希尔排序法排序的各趟的结果如下:
                初始:503,17,512,908,170,897,275,653,426,154,509,612,677,765,703,94
                第1趟{d1=8}:426,17,509,612,170,765,275,94,503,154,512,908,677,897,703,653
                第2趟(d2=4):170,17,275,94,426,154,509,612,503,765,512,653,677,897,703,908
                  第3趟(d3=2):170,17,275,94,426,154,503,612,509,653,512,765,677,897,703,908
                第4趟(d1=1):17,94,154,170,275,426,503,509,512,612,653,677,703,765,897,908

    2.希尔排序算法实现

1. #include <iostream> using namespace std; void ShellPass(int R[], int d, int n) { for(int i = d; i <= n; i++) { if(R[i] < R[i -d]) { int j; int tem = R[i]; j = i -d; do{ R[j + d] = R[j]; j = j - d; }while(j > 0 && tem < R[j]); R[j + d] = tem; } } } void ShellSort(int R[], int n) { int increment = n; do{ increment = increment/3 + 1;//求一下增量 ShellPass(R, increment, n); //一趟增量为increment的Shell插入排序 }while(increment > 1); } int main() { int a[10] = {10,2,36,12,1,25,42,13,21,11}; ShellSort(a, 9); for(int m = 0; m < 10; m++) { cout<<a[m]<<" "; } cout<<endl; return 0; } 

 

    3.希尔排序的算法分析
        1．增量序列的选择
    　    Shell排序的执行时间依赖于增量序列。
    　    好的增量序列的共同特征：
　　    ① 最后一个增量必须为1；
　　    ② 应该尽量避免序列中的值(尤其是相邻的值)互为倍数的情况。
    　    有人通过大量的实验，给出了目前较好的结果：当n较大时，比较和移动的次数约在n^l.25到1.6n^1.25之间。

        2．Shell排序的时间性能优于直接插入排序
    　    希尔排序的时间性能优于直接插入排序的原因：
　　    ①当文件初态基本有序时直接插入排序所需的比较和移动次数均较少。
　　    ②当n值较小时，n和n²的差别也较小，即直接插入排序的最好时间复杂度O(n)和最坏时间复杂度0(n²)差别不大。
　　    ③在希尔排序开始时增量较大，分组较多，每组的记录数目少，故各组内直接插入较快，后来增量d_i逐渐缩小，分组数逐渐减少，而各组的记录数目逐渐增多，但由于已经按d_i-1作为距离排过序，使文件较接近于有序状态，所以新的一趟排序过程也较快。
    　    因此，希尔排序在效率上较直接插人排序有较大的改进。

        3．稳定性
    　    希尔排序是不稳定的。参见上述实例，该例中两个相同关键字49在排序前后的相对次序发生了变化。