北京赛车平台出租皇冠体育平台出租幸运快三平台出租JAVA冒泡排序算法面试题

北京赛车平台出租皇冠体育平台出租幸运快三平台出租（www.1159880099.com） QQ1159880099 微信 Tel17061863533 

JAVA冒泡排序算法面试题

冒泡排序（从小到大排）：以从小到大排序为例，每一轮排序就找出未排序序列中最大值放在最后。

设数组的长度为N： 

（1）比较前后相邻的二个数据，如果前面数据大于后面的数据，就将这二个数据交换。

（2）这样对数组的第0个数据到N-1个数据进行一次遍历后，最大的一个数据就“沉”到数组第N-1个位置。

（3）N=N-1，如果N不为0就重复前面二步，否则排序完成。

北京赛车平台出租 （www.1159880099.com） QQ1159880099 微信 Tel17061863533 

皇冠体育平台出租 （www.1159880099.com） QQ1159880099 微信 Tel17061863533 

幸运快三平台出租 （www.1159880099.com） QQ1159880099 微信 Tel17061863533 

[java] view plain  copy

 

1. /** 
2.  * 冒泡排序的第一种实现, 没有任何优化 
3.  */  
4. public static void bubbleSort1(int [] a, int n){  
5.     int i, j;  
6.   
7.     for(i=0; i<n; i++){//表示n次排序过程。  
8.         for(j=1; j<n-i; j++){  
9.             if(a[j-1] > a[j]){//前面的数字大于后面的数字就交换  
10.                 //交换a[j-1]和a[j]  
11.                 int temp;  
12.                 temp = a[j-1];  
13.                 a[j-1] = a[j];  
14.                 a[j]=temp;  
15.             }  
16.         }  
17.     }  
18. }// end  

[java] view plain  copy

 

1. 给出一个测试代码：  
2.   
3. public static void main(String[] args) {  
4.     int[] arr = {1,1,2,0,9,3,12,7,8,3,4,65,22};  
5.   
6.     BubbleSort.bubbleSort1(arr, arr.length);  
7.   
8.     for(int i:arr){  
9.         System.out.print(i+",");  
10.     }  
11. }  

运行结果：

0,1,1,2,3,3,4,7,8,9,12,22,65,

下面开始考虑优化，如果对于一个本身有序的序列，或则序列后面一大部分都是有序的序列，上面的算法就会浪费很多的时间开销，这里设置一个标志flag，如果这一趟发生了交换，则为true，否则为false。明显如果有一趟没有发生交换，说明排序已经完成。

[java] view plain  copy

 

1. /** 
2.  * 设置一个标志，如果这一趟发生了交换，则为true，否则为false。明显如果有一趟没有发生交换，说明排序已经完成。 
3.  */  
4. public static void bubbleSort2(int [] a, int n){  
5.     int j, k = n;  
6.     boolean flag = true;//发生了交换就为true, 没发生就为false，第一次判断时必须标志位true。  
7.     while (flag){  
8.         flag=false;//每次开始排序前，都设置flag为未排序过  
9.         for(j=1; j<k; j++){  
10.             if(a[j-1] > a[j]){//前面的数字大于后面的数字就交换  
11.                 //交换a[j-1]和a[j]  
12.                 int temp;  
13.                 temp = a[j-1];  
14.                 a[j-1] = a[j];  
15.                 a[j]=temp;  
16.   
17.                 //表示交换过数据;  
18.                 flag = true;  
19.             }  
20.         }  
21.         k--;//减小一次排序的尾边界  
22.     }//end while  
23. }//end  

运行测试main函数结果：

0,1,1,2,3,3,4,7,8,9,12,22,65,

再进一步做优化。比如，现在有一个包含1000个数的数组，仅前面100个无序，后面900个都已排好序且都大于前面100个数字，那么在第一趟遍历后，最后发生交换的位置必定小于100，且这个位置之后的数据必定已经有序了，也就是这个位置以后的数据不需要再排序了，于是记录下这位置，第二次只要从数组头部遍历到这个位置就可以了。如果是对于上面的冒泡排序算法2来说，虽然也只排序100次，但是前面的100次排序每次都要对后面的900个数据进行比较，而对于现在的排序算法3，只需要有一次比较后面的900个数据，之后就会设置尾边界，保证后面的900个数据不再被排序。

[java] view plain  copy

 

1. public static void bubbleSort3(int [] a, int n){  
2.     int j , k;  
3.     int flag = n ;//flag来记录最后交换的位置，也就是排序的尾边界  
4.   
5.     while (flag > 0){//排序未结束标志  
6.         k = flag; //k 来记录遍历的尾边界  
7.         flag = 0;  
8.   
9.         for(j=1; j<k; j++){  
10.             if(a[j-1] > a[j]){//前面的数字大于后面的数字就交换  
11.                 //交换a[j-1]和a[j]  
12.                 int temp;  
13.                 temp = a[j-1];  
14.                 a[j-1] = a[j];  
15.                 a[j]=temp;  
16.   
17.                 //表示交换过数据;  
18.                 flag = j;//记录最新的尾边界.  
19.             }  
20.         }  
21.     }  
22. }  

最优化的冒泡排了。
运行测试例子结果：

0,1,1,2,3,3,4,7,8,9,12,22,65,