冒泡排序算法是一种较为简单的并且稳定的排序算法，该算法的时间复杂度最好为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     }