经典算法学习：排序之冒泡排序

简介

不同的排序算法适用于不同的实际环境中，主要考虑以下的因素：

1.时间复杂度（算法执行时间）

2.空间复杂度（存储空间）

3.代码量

对于数据量比较小的排序，1,2所产生的差别不大，主要考虑3；对于数据量较大的排序，主要考虑1。

10种排序算法：

1.冒泡排序————Bubble，相邻交换

2.选择排序———每次最小/最大排在相应位置

3.插入排序————将下一个数据插入到已经排好的序列中

4.壳排序————Shell，缩小增量

5.归并排序

6.快速排序

7.堆排序

8.拓扑排序

9.锦标赛排序

10.基数排序

冒泡排序

思想

冒泡排序是最简单最基本的排序方法之一。冒泡排序的思想很简单，就是以此比较相邻的元素大小，将小的前移，大的后移，就像水中的气泡一样，最小的元素经过几次移动，会最终浮到水面上。

举例分析说明一下，如下数据：

2 7 4 6 9 1 首先比较最后两个数字，发现1比9小，于是前移

2 7 4 6 1 9 然后比较6和1

2 7 4 1 6 9 继续前移，然后是4和1

2 7 1 4 6 9 7和1比较

2 1 7 4 6 9 2和1

1 2 7 4 6 9 至此，第一趟冒泡过程完成，最小的元素1被移到第一个，不再参与后面的排序过程。下一趟冒泡过程同理，比较6和9，以此类推，最终得到结果。

代码示例：

[java] view plaincopyprint?

1. void sort(int s[]) {  
2.         for (int i = 0; i < s.length; i++) {  
3.             for (int j = 0; j < i; j++) {  
4.                 int temp = 0;  
5.                 if (s[i] < s[j]) {  
6.                     temp = s[i];  
7.                     s[i] = s[j];  
8.                     s[j] = temp;  
9.                 }  
10.             }  
11.         }  
12.     }  

冒泡排序进行两次遍历，时间复杂度为O(n²)，适用于较小的数据量排序。

算法优化：

因为每一趟排序都使有序区增加了一个气泡，在经过n-1趟排序之后，有序区中就有n-1个气泡，而无序区中气泡的重量总是大于等于有序区中气泡的重量，所以整个冒泡排序过程至多需要进行n-1趟排序。以此本算法的时间复杂度还是O(n*n)，也不能算是一个高效的算法。

细心分析不难发现，本算法还有可以优化的空间，若在某一趟排序中未发现气泡位置的交换，则说明待排序的无序区中所有气泡均满足轻者在上，重者在下的原则，因此，冒泡排序过程可在此趟排序后终止。为此，在下面给出的算法中，引入一个布尔量exchange，在每趟排序开始前，先将其置为FALSE。若排序过程中发生了交换，则将其置为TRUE。各趟排序结束时检查exchange，若未曾发生过交换则终止算法，不再进行下一趟排序。这样可以减少不必要的比较。代码如下

[java] view plaincopyprint?

1. public static void sort1(int s[]) {  
2.         boolean exchange = false;  
3.         for (int i = 0; i < s.length; i++) {  
4.             for (int j = 0; j < i; j++) {  
5.                 int temp = 0;  
6.                 if (s[i] < s[j]) {  
7.                     temp = s[i];  
8.                     s[i] = s[j];  
9.                     s[j] = temp;  
10.                     exchange = true;  
11.                 }  
12.                 if (!exchange) {  
13.                     break;  
14.                 }  
15.             }  
16.         }  
17.     }