何为冒泡排序？

冒泡：就像气泡从水中冒出来一样

在冒泡排序中，最小数或最大数取决于您是按升序还是降序对数组进行排序，向上冒泡到数组的开头或结尾。

算法描述：

1. 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
3. 针对所有的元素重复以上的步骤，除了最后一个；
4. 重复步骤1~3，直到排序完成。

 如果两个元素相等，不会再交换位置，所以冒泡排序是一种稳定排序算法。

代码实现：

数组排序

    /*
       对数组a中的元素进行排序
    */
    public static void sort(Comparable[] a){
        for(int i=a.length-1;i>0;i--){
            for(int j=0;j<i;j++){
                //{6,5,4,3,2,1}
                //比较索引j和索引j+1处的值
                if (greater(a[j],a[j+1])){
                    exch(a,j,j+1);
                }
            }
        }
    }

比较v元素是否大于w元素

    private static  boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }

数组元素i和j交换位置

    private static void exch(Comparable[] a,int i,int j){
        Comparable temp;
        temp = a[i];
        a[i]=a[j];
        a[j]=temp;
    }

排序类

    public static void bubbleSort(int[] data) {

        int arrayLength = data.length;

        for (int i = 1; i < arrayLength; i++) {//第i次排序

            for (int j = 0; j < arrayLength - i; j++) {//从索引为j的数开始
                if (data[j] > data[j + 1]) { //相邻元素两两对比
                    int temp = data[j + 1];  // 元素交换
                    data[j + 1] = data[j];
                    data[j] = temp;
                }
            }

            System.out.println("第" + i + "次排序：
" + java.util.Arrays.toString(data));
        }
    }

完整代码：

	public class BubbleSort {
    public static void bubbleSort(int[] data) {

        	        int arrayLength = data.length;

        	        for (int i = 1; i < arrayLength; i++) {//第i次排序

        	            for (int j = 0; j < arrayLength - i; j++) {//从索引为j的数开始
        	                if (data[j] > data[j + 1]) { //相邻元素两两对比
        	                    int temp = data[j + 1];  // 元素交换
        	                    data[j + 1] = data[j];
        	                    data[j] = temp;
        	                }
        	            }

        	            System.out.println("第" + i + "次排序：
" + java.util.Arrays.toString(data));
        	        }
        	    }

        	    public static void main(String[] args) {

        	        int[] data = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};

        	        System.out.println("排序之前：
" + java.util.Arrays.toString(data));

        	        bubbleSort(data);

        	        System.out.println("排序之后：
" + java.util.Arrays.toString(data));
        	    }
        	}

排序之前：
[3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
第1次排序：
[3, 38, 5, 44, 15, 36, 26, 27, 2, 46, 4, 19, 47, 48, 50]
第2次排序：
[3, 5, 38, 15, 36, 26, 27, 2, 44, 4, 19, 46, 47, 48, 50]
第3次排序：
[3, 5, 15, 36, 26, 27, 2, 38, 4, 19, 44, 46, 47, 48, 50]
第4次排序：
[3, 5, 15, 26, 27, 2, 36, 4, 19, 38, 44, 46, 47, 48, 50]
第5次排序：
[3, 5, 15, 26, 2, 27, 4, 19, 36, 38, 44, 46, 47, 48, 50]
第6次排序：
[3, 5, 15, 2, 26, 4, 19, 27, 36, 38, 44, 46, 47, 48, 50]
第7次排序：
[3, 5, 2, 15, 4, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
第8次排序：
[3, 2, 5, 4, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
第9次排序：
[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
第10次排序：
[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
第11次排序：
[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
第12次排序：
[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
第13次排序：
[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
第14次排序：
[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
排序之后：
[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]

Process finished with exit code 0