思路分析

冒泡排序是每次找到一个最大值或者最小值，放到合适的位置上，借助相邻元素比较交换的方式来完成。

具体思路如下：用cur和cur+1两个位置进行比较，如果cur大于cur+1位置的值，那么就将两个位置的值交换，之后让cur+1继续比较交换，直到cur+1等于数组长度的时候为止，这样就可以把整个数组中最大的元素找到，放到了数组末尾，到此就已经完成了第一趟排序。

接着重复以上过程，直到整个数组排序完成

图解

按照如图所示的思路继续进行后续的第4趟……第n趟冒泡排序，直到排序完成。

代码示例

方法一：从前往后进行遍历，就是每次找最大

private static void exchange(int[] array, int bound, int cur) {
    int tmp = array[bound];
    array[bound] = array[cur];
    array[cur] = tmp;
}
public static void bublesertSort(int[] array){
    for (int bound = 0; bound < array.length; bound++){
        for (int cur = 0; cur < array.length -1- bound; cur++){
            if (array[cur] > array[cur+1]){
                exchange(array, cur, cur+1);
            }
        }
    }
}

方法二：从后往前，就是每次找最小

private static void exchange(int[] array, int bound, int cur) {
    int tmp = array[bound];
    array[bound] = array[cur];
    array[cur] = tmp;
}
 public static void bubbleSort(int[] array){
    for (int bound = 0; bound < array.length; bound++){
        for (int cur = array.length - 1; cur > bound; cur--){
            if (array[cur-1] > array[cur]){
                exchange(array, cur-1, cur);
            }
        }
    }
}

优化：

 //优化
public static void bubbleSort2(int[] array){
    boolean flg = false; //没有发生交换 
    for (int i = 0; i < array.length; i++){
        for (int j = 0; j < array.length - 1 - i; j++){
            if (array[j] > array[j + 1]){
                int tmp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = tmp;
                flg = true;
            }
        }
        if (flg == false){
            break;
        }
    }
}

性能分析

时间复杂度： 最好：O(N) {数据有序} 平均：O(N^2) 最坏：O(N^2) {数组逆序}

空间复杂度： O(1)

稳定性： 稳定排序