冒泡排序是一种流行但低效的排序算法，它的作用是反复交换相邻的未按次序排列的元素。
算法的比较次数为：
　　　　　　 n−1,n−2,⋯,1=n(n−1)/2

最坏的运行的时间为Θ(n^2).

下面是代码

/**
 * @Project: 10.dataStructure
 * @description:  冒泡排序
 * @author: sunkang
 * @create: 2018-08-19 21:35
 * @ModificationHistory who      when       What
 **/
public class DubboSort {
    /**
     * 冒泡算法
     *  1
     *  3
     *  4
     *  2    向上冒
     *核心思想：从数组对底层数据与相邻的数据进行比较，大的就进行交换，然后在进行比较，交换，循环一轮，最大的数据就冒上去
     *
     * 效率问题：这种也是从数组通过冒泡的形式从剩余数组找到最小或者最大的数据来实现的
     *          跟插入排序是一样的，但还是这里进行了比较之后每次需要交换，效率低
     * 时间复杂度： O(N²)
     *设置数据的为A
     * 分析：  需要多少轮：A.length -1 (最后只有一个数据，无需进行比较，比如数据大小为5的数组只需要循环4次已经有最大的四个数据出来了，最后一次无需比较)
     *         每一轮下标从哪里循环：A.length-1（数组的最后一个元素）
     *         什么时候进行交换数据： A[j-1] > A[j]; 底下小于上面的进行交换，出来的就是从小到大，反之亦然 A[j-1] <A[j],从大到小
     * @param A
     * @return
     */
    public  Integer[] dubboSort(Integer[] A){
        //循环A.length -1 轮
        for(int i= 0 ; i <A.length -1;i++){
            //从A.length-1 开始循环,截止时j 必须大于i
            for(int j = A.length -1; j> i; j-- ){
                if( A[j -1] > A[j]){
                    swap(A,j-1,j);
                }
            }
        }
        return A;
    }

    /**
     * 交换数组A的两个数据
     * @param A
     * @param i
     * @param j
     */
    private   void   swap(Integer[] A,int i ,int j  ){
        //暂存的数据
        int temp = A[i];
        //A[i]的数据引用指向A[j],完成A[i]的数据变成A[j]
        A[i]= A[j];
        //A[j]的数据执行引用temp,完成A[j]的数据变成A[i]
        A[j]=temp;
    }

    public  void display(Integer[] objects){
        for(Integer in:objects){
            System.out.print(in+",");
        }
        System.out.println();
    }
    public static void main(String[] args) {
        Integer[] arr  = new Integer[]{1,2,7,4,3,9};
        DubboSort  dubboSort = new DubboSort();
        dubboSort.dubboSort(arr);
        dubboSort.display(arr);
    }
}