冒泡排序算法是一種較為簡單的並且穩定的排序算法，該算法的時間復雜度最好為O(n)，最差時為O(n^2)，需要的空間復雜度為O(1)。

這裏的算法穩定性是指 經過排序後，各元素仍然能保持它們在排序之前的相對次序，就稱該算法是穩定的，反之，則為不穩定的。

例如，一組數排序前是a1,a2,a3,a4,a5,其中a2=a4，經過某種排序後a1,a2,a4,a3,a5,則說明這種排序是穩定的，因為a2排序前後都在a4前面；若排序的結果是a1,a4,a2,a3,a5,則該排序就不是穩定的了。------摘自《Java程序員面試筆試寶典》

一種較為常見的冒泡排序算法如下：

 1     /**
 2      * 冒泡排序
 
 3      * @param data 輸入為一個待排序的整形數組
 4      */
 5     public static int[] bubbleSort(int[] data){
 6         int size = data.length;
 7         for(int i=0;i<size-1;i++){
 8             for(int j=0;j<size-1-i;j++){
 9                 if(data[j]>data[j+1]){
10                     int temp = data[j];
 
11                     data[j] = data[j+1];
12                     data[j+1] = temp;
13                 }
14             }
15         }
16         return data;
17     }

可以看出，經典的冒泡排序是選擇從一端開始，通過比較相鄰元素大小並交換次序的。實際上對冒泡排序加以改進，從兩端進行排序，也就是所謂的“雙向冒泡排序”，可以有更好的效率。如果按照排序結果從小到大輸出，可以按照“較大氣泡從左到右移動，較小氣泡從右到左移動”來實現雙向冒泡排序的效果；一種實現代碼（Java版）如下：

 1 /**
 2      * 雙向冒泡排序
 3      * @param num
 4      */
 5     public static int[] doubleBuddleSort(int[] num){
 6         int left=0,right = num.length-1;
 7         while(left<right){
 8             //較大氣泡從左邊向右邊移動
 9             for(int i=left+1;i<=right;i++){
10                 if(num[left]>num[i]){
11                     int temp = num[left];
12                     num[left] = num[i];
13                     num[i] = temp;
14                 }
15             }
16             left++;
17             
18             //較小氣泡從右邊向左邊移動
19             for(int i=right-1;i>=left;i--){
20                 if(num[i]>num[right]){
21                     int temp = num[right];
22                     num[right] = num[i];
23                     num[i] = temp;
24                 }
25             }
26             right--;
27         }
28         
29         return num;
30     }

Java版雙向冒泡排序算法