排序算法之冒泡算法

public class TestSort{
/**
* 
* 冒泡算法1
* 实现大的数字往后冒
* @param a
* @return
*/
public  int[] bubbleSort_1(int a[]){
int temp;
for (int i=0;i<a.length;i++){
for(int j=1;j<a.length-i;j++){
if(a[j]<a[j-1]){
temp=a[j];
a[j]=a[j-1];
a[j-1]=temp;
}
}
}
return a;
}
/**
* 冒泡算法2
* 实现小的数字往前冒
* @param a
* @return
*/
public  int[] bubbleSort_2(int a[]){
int temp;
for (int i=0;i<a.length;i++){
for(int j=a.length-1;j>i;j--){
if(a[j]<a[j-1]){
temp=a[j];
a[j]=a[j-1];
a[j-1]=temp;
}
}
}
return a;
}

public static void main(String[] args) {
int a[]={3,6,24,12,17,45,43,25,1,7,9};
TestSort sort=new TestSort();
int b[]=sort.bubbleSort_2(a);
for(int i=0;i<b.length;i++){
System.out.println(b[i]);
}
}

}

冒泡算法的实现比较简单，其时间的复杂度为O(n^2).

教科书上写着冒泡算法在数列原本就是正序的时候性能最好，最好的时间为O(n).

这其实是给人造成误解的。

因为以上的冒泡算法的实现无论是在数列顺序怎样的情况下时间复杂度都为O(n^2),当数列为正序的情况下只是元素交换的三个步骤省去了，当然性能得到了提升，但是其比较的次数并没有得到减少，因此时间复杂度并没有变化。

而书上提到的O(n)的情况是经过以上的冒泡算法改进的。

其源代码如下：

public void bubbleSort(int arr[]) {
   boolean didSwap;
   for(int i = 0, len = arr.length; i < len - 1; i++) {
       didSwap = false;
       for(int j = 0; j < len - i - 1; j++) {
           if(arr[j + 1] < arr[j]) {
               swap(arr, j, j + 1);
               didSwap = true;
           }
       }
       if(didSwap == false)
           return;
   }    
}