经典排序算法-冒泡排序（java实现）

原理

依次两两比较相邻的元素大小，将较大的放在右边，这样每趟下来就把最大的值放到了最右边，重复以上步骤(n-1)趟，就实现了把所有元素升序排列。

举例（以升序为例）

原始数组：3 8 2 9 1 4
第一趟:      3 2 8 1 4 9
第二趟:      2 3 1 4 8 9
第三趟:      2 1 3 4 8 9
第四趟:      1 2 3 4 8 9
第五趟:      1 2 3 4 8 9

最后一趟，就剩最后一个元素1，一定是最小的，就不用再比较了，因此总共需要比较(n-1)趟，n为数组长度。
其实也可以看到，第四趟的时候，数组就已经是升序的，不再需要比较了。因此可以优化，当没有数据可以交换时，就认为已经达到有序状态

代码实现

public static void main(String[] args) {
    int[] arr = {1,23,98,25,4,7,8,35};
    bubbleSort(arr);
    System.out.println("排序后为:");
    System.out.println(Arrays.toString(arr));
}

public static void bubbleSort(int[] arr){
    for (int i = 0; i < arr.length - 1; i++) { //总共需要比较（n-1）趟
        boolean sortedFlag = true;
        for (int j = 0; j < arr.length - 1 - i; j++) { //每趟需要比较（n-i）次,1<=i<=n-1
            if(arr[j]>arr[j+1]){
                int t = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = t;
                sortedFlag = false;
            }
        }
        if(sortedFlag) break;
    }
}

打印结果为：[1, 4, 7, 8, 23, 25, 35, 98]

时间复杂度

1、如果原始数组本来就是升序，则只需要比较一趟，循环(n-1)次内层循环比较，时间复杂度为O(n)
2、如果最坏情况本来数组是反序的，则需要比较(n-1)趟，每趟进行(n-i)次比较，1<=i<=n-1，时间复杂度为O(n^2)
综上，冒泡排序的时间复杂度为O(n^2)

空间复杂度

由于冒泡排序只是数组内的元素交换，并没有占用额外的存储空间，因此空间复杂度为O(1)