排序算法

 

一、介绍

排序算法已经是老话新谈了的话题了，但在网上很少找到比较系统的总结。有的只给出代码，有的分析的很笼统等。如果大学学的是计算机专业，那么这些东西都是必须要学的。

 

排序是我们工作中经常碰到的一件事，基本每个项目都涉及到排序运算。一般，排序操作在数据处理过程中要话费许多时间。为了提高计算机的运行效率，人们提出不断改进各种各样的排序算法，而这些算法也从不同角度展示了算法设计的某些重要原则和技巧。

 

排序就是将一组对象按照规定的次序重新排列的过程，排序往往是为检索服务的。例如，学生档案系统里面的学生成绩信息就是按照学号、年龄或入学成绩等排序后的结果，在排好序的结果里面检索学生成绩信息效率就高很多了。如下表1-1就是按照年龄升序排列的学生信息列表。

表1-1       按学号升序排序学生成绩表

学号	姓名	性别	年龄	成绩
20060206	吴三	男	18	523
20060207	李四	男	19	450
20060208	王五	女	18	470
20060209	赵柳	女	17	485.5

 

表1-2       按学号升序排序学生成绩表

学号	姓名	性别	年龄	成绩
20060209	赵柳	女	17	485.5
20060208	王五	女	18	470
20060206	吴三	男	18	523
20060207	李四	男	20	450

 

可以看出学号为20060206和20060208的两位同学年龄都为18岁，表1-2按照年龄升序后相对位置发生变化了。对于这种相同键值的两个记录在排序前后相对位置变化情况是排序算法研究中经常关注的一个问题，该问题成为排序算法的稳定性。需要注意的是：稳定性是算法本身的特性，与数据无关。

 

排序算法分为内部排序和外部排序。内部排序是将待排序的记录全部放在计算机内存中进行的排序过程，其排序实现方法很多，主要有插入排序、选择排序、交换排序和归并排序等；如果待排序的记录数量很大，内存不能存储全部记录，需要对外存进行访问排序的过程，本次总结的是内部排序。

 

评价一个算法的优劣，通常是用时间复杂度和控件复杂度这两个指标。由于排序算法的多样性，很难确定一种公认的最好方法，应当根据实际应用选择不同的方法。例如，当带排序序列已基本有序时，插入排序和交换排序比较有效；当待排记录数量较大时，选择排序有效。

二、比较

 

对20000条记录进行排序：

名称                                                        耗时（毫秒） 插入排序（直接插入）                   1469 交换排序（冒泡排序）                   5828 交换排序（快速排序）                   1078 选择排序（直接选择排序）             2796 选择排序（堆排序）                       16 归并排序（二路归并）                    0

三、内部排序

（一）插入排序

它的基本思想是将记录分为有序区和无序区，将无序区中的记录依次插入到有序区中，并保持有序。常用的插入排序方法有直接插入排序、拆半插入排序、表插入排序和希尔排序等。如果待排记录较少且基本有序的话，可以考虑使用插入排序算法。

 

1.直接插入排序

根据插入排序算法的基本思想，图3-1便是直接插入排序算法的过程，中括号内是有序区，中括号外面是无序区。从无序区的前面或后面依次取出一个元素，在有序区找到一个合适的位置插入。这里所说的合适位置要看是升序还是降序。

图3-1 直接插入排序示意图

 

Java代码  

1. /** 
2.  * 插入排序——直接插入排序 
3.  * @param arrays 待排序序列 
4.  * @dateTime 2014-2-16 上午09:15:08 
5.  * @author wst 
6.  * @return void 
7.  */  
8. public static void insertSort(int[] arrays){  
9.     int i,j,n=arrays.length-1;  
10.     for(i=1;i<=n;i++){//第一个元素无须排序  
11.         int temp=arrays[i];//当前比较元素  
12.         //在已排好序的序列里找到一个合适的位置存放temp  
13.         for(j=i;j>0&&temp<arrays[j-1];j--){  
14.             arrays[j]=arrays[j-1];//将大的元素后移  
15.         }  
16.         arrays[j]=temp;  
17.     }  
18. }  

 

 

（二）交换排序

交换排序的基本思想是两两比较待排序的记录，当记录之间值出现逆序时，则交换两个记录。常用的交换排序有冒泡排序和快速排序等。

1.冒泡排序

冒泡排序的过程是首先将第一个记录和第二个记录进行比较，若为逆序，则将这两个记录交换，然后继续比较第二个和第三个记录。依次类推，直到完成第n-1个记录和第n个记录比较交换为止。上述过程称为第一趟起泡，其结果使最大的记录已到了第n个位置上。重复以上起泡过程，当在一趟起泡过程中没有进行记录交换的操作时，整个排序过程终止。因为每趟起泡都有一个最大的记录沉到水底，所以整个排序过程最多需要进行n-1趟起泡。例如，图3-2是冒泡排序过程的示意图，图中只给出了第一趟起泡的过程，后面直接给出各趟起泡结果。在起泡结果里面，有黄色背景的记录已经排好序。

图3-2       冒泡排序示意图

 

从图3-2中可以看出，当第4趟起泡结束后已经没有需要交换的气泡了，第5、6趟起泡纯属多余，因为此时序列已经有序，因此在第4趟起泡结束后可以终止循环。起泡次数=4<n-1，符合上面的推理。

 

Java代码  

1. /** 
2.  * 交换排序——冒泡排序 
3.  * @param arrays 
4.  * @dateTime 2014-1-25 上午10:41:58 
5.  * @author wst 
6.  * @return void 
7.  */  
8. public static void upBubbleSort(int[] arrays){  
9.     int i,j,n=arrays.length;  
10.     for(i=0;i<n-1;i++){  
11.         boolean endsort=true;//是否需要交换  
12.         for(j=0;j<n-i-1;j++){  
13.             if(arrays[j]>arrays[j+1]){  
14.                 int temp=arrays[j];  
15.                 arrays[j]=arrays[j+1];  
16.                 arrays[j+1]=temp;  
17.                 endsort = false;  
18.             }  
19.         }  
20.         if(endsort){  
21.             break;  
22.         }  
23.     }  
24. }  

 

 

2.快速排序

快速排序实质上是对冒泡排序的一种改进。其基本思想是：以选定的记录为基准，将带排序表划分为左、右两段，其中左边所有记录小于等于右边所有记录，然后，对左、右两段记录分别进行快速排序。如下图3-3是快速排序的示意图，下图给出了第一趟快速排序的完整过程，后面相继只给出各趟排序结果。红色记录表示各趟记录划分出的关键字，中括号内的记录表示根据关键字划分的无序区。

 图3-3       快速排序示意图

 

Java代码  

1. /** 
2.  * 交换排序——快速排序 
3.  * 不稳定。O(nlog2n)~O(n2)。 
4.  * 待排序列基本有序时效率低 
5.  * @param arrays 
6.  * @param low  
7.  * @param high 
8.  * @dateTime 2014-2-16 上午09:34:24 
9.  * @author wst 
10.  * @return int[] 
11.  */  
12. public static int[] quickSort(int[] arrays,int low,int high){  
13.     if(low<high){  
14.         //划分区域，找出关键字  
15.         int temp=quickPartition(arrays,low,arrays.length-1);  
16.         //在关键字左侧进行排序  
17.         quickSort(arrays,low,temp-1);  
18.         //在关键字右侧进行排序  
19.         quickSort(arrays,temp+1,high);  
20.     }  
21.     return arrays;  
22. }  
23.       
24. /** 
25.  * 对子序列进行一趟快速排序 
26.  * @param arrays 待排序序列 
27.  * @param low 当前排序序列的首指针 
28.  * @param high 当前排序序列的末指针 
29.  * @dateTime 2014-2-16 上午09:38:01 
30.  * @author wst 
31.  * @return int 
32.  */  
33. private static int quickPartition(int[] arrays,int low,int high){  
34.     int x=arrays[low];//初始值  
35.     while(low<high){  
36.         while(low<high&&(arrays[high]>=x)){  
37.             high--;//从末端找出一个比x小的数  
38.         }  
39.         //将找到的比x小的元素移到low位置  
40.         arrays[low]=arrays[high];  
41.         while(low<high&&(arrays[low]<=x)){  
42.             low++;//从首端找出一个比x大的数  
43.         }  
44.         //将找到的比x大的元素移到high位置  
45.         arrays[high]=arrays[low];  
46.     }  
47.     //一趟快速排序结束后，将x置入low位置  
48.     arrays[low]=x;  
49.     return low;  
50. }  

 

（三）选择排序

选择排序的基本思想：每次从待排序列中选取记录最小或最大的放到适当位置。常用的选择排序法有直接选择排序和堆排序法等。选择排序适合待排记录较大的情况。

1.直接选择排序

直接选择排序算法的基本思想：在待排序的无序区中选择最小（大）的记录，并将该记录放到有序区的最前（后）端。图3-4是直接选择排序过程的示意图。中括号内是有序区，每次从中括号外面选择出一个最小或最大的记录放到有序区。该算法简单容易实现。

图3-4       直接选择排序示意图

 

Java代码  

1. /** 
2.  * 选择排序——直接选择 
3.  * 不稳定。O(n2)。待排记录较多效率非常低下 
4.  * @param arrays 
5.  * @dateTime 2014-2-16 上午09:57:13 
6.  * @author wst 
7.  * @return void 
8.  */  
9. public static void selectSort(int[] arrays){  
10.     int n=arrays.length,minIndex=0,temp=0;  
11.     if(arrays==null||n==0){  
12.         return;  
13.     }  
14.     for(int i=0;i<n;i++){        //每一趟都选择出一个最小值  
15.         minIndex=i;             //待排区的最小元素下标  
16.         for(int j=i+1;j<n;j++){  //在待排区中找出最小元素  
17.             if(arrays[j]<arrays[minIndex]){  
18.                 minIndex=j;  
19.             }  
20.         }  
21.         if(minIndex!=i){//将找到的最小元素置入有序区  
22.             temp=arrays[i];  
23.             arrays[i]=arrays[minIndex];  
24.             arrays[minIndex]=temp;  
25.         }  
26.     }  
27. }  

 

2.堆排序

堆排序是利用堆来选择最小（大）记录。对直接选择排序的分析我们可以知道，在n个记录中选出最小值，至少要进行n-1次比较。然而继续在剩余的n-1个记录中选出次小记录是否一定要进行n-2次比较呢？若能利用前n-1次比较所得信息，是否可以减少以后各次选择中的比较次数呢？答案是肯定的。堆有最小堆和最大堆，简单定义如下：

序列{k1,k2,…,kn}满足

其中，i=1,2,…,n/2，则称这个n个记录的序列{k1,k2,…,kn}为最小堆（或最大堆）。根据上述定义可以知道，最小堆可以看成是一棵以k1为根的完全二叉树，在这课二叉树中，任一结点的值都不大于它的两个孩子的值（若孩子存在的话）；最大堆可以看成是一棵以k1为根的完全二叉树，在这棵二叉树中，任一结点的值都不小于它的两个孩子的值（若存在孩子的话）。

 

由此可知，依次输出堆顶元素就可以得到升序或降序的序列。因此，实现堆排序需要解决两个问题：

（1）如何由一个初始序列建成一个堆？

（2）如何在输出堆顶元素之后调整剩余元素成为一个新堆？

如图3-5可以回答第一个问题，图3-6则回答了第二个问题。以下是由初始序列｛65,88,55,34,93,28,18,40｝建立堆和调整堆的全排序过程。

图3-5将初始序列建立一个堆

 

图3-6调整剩余元素成为一个新堆

 

Java代码  

1. /** 
2.  * 堆排序 
3.  * @param a 
4.  * @dateTime 2014-3-5 下午07:12:31 
5.  * @author wst 
6.  * @return void 
7.  */  
8. public static void heapSort(int[] a){  
9.     int n=a.length;  
10.     int temp=0;  
11.     //由初始序列建立一个堆  
12.     for(int i=n/2;i>0;i--){  
13.         sift(a,i-1,n);  
14.     }  
15.     //输出堆顶元素，调整剩余元素成为一个新堆  
16.     for(int i=n-2;i>=0;i--){  
17.         temp=a[i+1];  
18.         a[i+1]=a[0];  
19.         a[0]=temp;  
20.         sift(a,0,i+1);  
21.     }  
22. }  
23.   
24. /** 
25.  * 执行一次筛选 
26.  * @param a 待排序列 
27.  * @param k 根元素下标 
28.  * @param n 待排序序列长度 
29.  * @dateTime 2014-3-5 下午07:07:34 
30.  * @author wst 
31.  * @return void 
32.  */  
33. public static void sift(int[] a,int k,int n){  
34.     int temp=a[k];  //根  
35.     int j=2*k+1;    //左孩子  
36.     while(j<=n-1){  
37.         if(j<n-1&&a[j]>=a[j+1]){  
38.             j++;  
39.         }  
40.         if(temp<a[j]){  
41.             break;      //筛选结束  
42.         }  
43.         a[(j-1)/2]=a[j];//根与左孩子交换  
44.         j=2*j+1;        //继续从左孩子筛选  
45.     }  
46.     a[(j-1)/2]=temp;  
47. }  

 

 

（四）归并排序

归并排序是将两个或两个以上的有序表合并成一个有序表。归并排序法有二路归并排序等。

1.二路归并

二路归并的基本思想：假设序列中有n个记录，可看成是n个有序的子序列，每个序列的长度为1。首先将每相邻的两个记录合并，得到[n/2]个较大的有序子序列，每个子序列包含2个记录，再将上述序列两两合并，得到[[n/2]/2]个有序子序列，如此反复，直至得到一个长度为n的有序序列为止，排序结束。如图3-7是二路归并排序过程的示意图。

图3-7二路归并排序示意图

 

Java代码

Java代码  

1. /** 
2.  * 归并排序——二路归并 
3.  * @param a 
4.  * @param n 
5.  * @dateTime 2014-3-4 下午09:15:21 
6.  * @author wst 
7.  * @return void 
8.  */  
9. static void margeSort(int[] a,int n){  
10.     int[] b=new int[n+1];  
11.     int h=1;  
12.     while(h<=n){  
13.         mergePass(a,b,h,n);  
14.         h=2*h;  
15.         mergePass(b,a,h,n);  
16.         h=2*h;  
17.     }  
18. }  
19.   
20. /** 
21.  * 执行一次归并 
22.  * 在含有n个记录的序列a中， 
23.  * 将长度各为h的相邻两个有序子序列合并为长度2h的一个有序序列 
24.  * @param a 待排序列 
25.  * @param b 合并后的序列 
26.  * @param h 子序列长度 
27.  * @param n 总长度 
28.  * @dateTime 2014-3-4 下午09:02:39 
29.  * @author wst 
30.  * @return void 
31.  */  
32. static void mergePass(int[] a,int[] b,int h,int n){  
33.     int i=0;  
34.     while(i<n-2*h+1){  
35.         merge(a,b,i,i+h-1,i+2*h-1);  
36.         i+=2*h;  
37.     }  
38.     if(i+h-1<n){  
39.         merge(a,b,i,i+h-1,n);  
40.     }else{  
41.         for(int t=i;t<=n;t++){  
42.             b[t]=a[t];  
43.         }  
44.     }  
45. }  
46.   
47.   
48. /** 
49.  * 有序序列的合并 
50.  * 将a[h],...,a[m]和a[m+1],...,a[n]两个有序序列合并为一个有序序列 
51.  * @param a 带排序序列 
52.  * @param b 合并后的序列 
53.  * @param h 子序列长度 
54.  * @param m 序列1的结束位置 
55.  * @param n 序列2的结束位置 
56.  * @dateTime 2014-3-4 下午09:07:38 
57.  * @author wst 
58.  * @return void 
59.  */  
60. static void merge(int[] a,int[] b,int h,int m,int n){  
61.     int k=h,j=m+1;//序列1的起始位置和序列2的起始位置  
62.     while((h<=m)&&(j<=n)){  
63.         if(a[h]<a[j]){  
64.             b[k]=a[h];  
65.             h++;  
66.         }else{  
67.             b[k]=a[j];  
68.             j++;  
69.         }  
70.         k++;  
71.     }  
72.     while(h<=m){//将a[h],...,a[m]剩余序列插入末尾  
73.         b[k]=a[h];  
74.         h++;  
75.         k++;  
76.     }  
77.     while(j<=n){//将a[h],...,a[m]剩余序列插入末尾  
78.         b[k]=a[j];  
79.         j++;  
80.         k++;  
81.     }  
82. }  

 

四、总结

一篇学习总结的完成，意味着一次学习的结束，其背后蕴含着许多艰辛的努力。要学算法，需要知道什么叫时间复杂度、空间复杂度，甚至需要去复习数学等等，学习需要坚强的毅力。只有第一次大伤脑筋，那么下一次再学习的时候就会得心应手。每一次总结都会有所进步，这些进步不只是计算机专业知识的体现，也体现在了语言表达、文字排版等方面上，当拿着这次的总结去和刚参加工作时的总结相比，已经不是一个级别之差，而是几个甚至十个级别之差。以前的总结缺少系统性，随感而发，知识的局部性和片面性很强。总之，有总结才会有反思，有反思才会有提高！

五、参考文献

郑诚.数据结构导论[M].外语教学与研究出版社，2012