public class BubbleSortTest {

    public static void main(String [] args){
        
        int arr[] = {1,3,2,0};
        int arrLowToHigh[] = {1,2,3,4};
        int arrHighToLow[] = {4,3,2,1};
        print(arr);
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = i+1; j < arr.length; j++) {
                if(arr[i]>arr[j]){
                    swap(arr, i, j);
                    print(arr);
                }
            }
        }
　　　　　print(arr);　
    }

    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    
    private static void print(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"\t");
        }
        System.out.println("\n");
    }
}

我们都知道冒泡排序的时间复杂度为O(n^2)。

我就来总结一下冒泡排序。

SRE实战 互联网时代守护先锋，助力企业售后服务体系运筹帷幄！一键直达领取阿里云限量特价优惠。

排序的时间复杂度主要是：比较+交换

首先来看下最优情况下 arrLowToHigh[] 数组已经是从小到大排列，所以 最优时间复杂度为O(n)，一次都不用交换;

最坏的是情况 arrHighToLow[] 要完全倒序，每次进入都要交换，所以时间复杂度为O(n^2);

接下来分析一下一般情况下的乱序；

我这里举了一个4个元素的数组

 

arr[] = {1,3,2,0};

数组排列出始排列 ： 1　　3　　2　　0

 

1.进入大循环后 i=0,进入内循环 j=i+1(=1)　arr[0]<arr[1]　　条件不成立，不用交换

i=0 j=1　　arr[0]<arr[1]　　条件不成立，不用交换

i=0 j=2　　arr[0]<arr[2]　　条件不成立，不用交换

i=0 j=3　　arr[0]<arr[3]　　条件成立，交换　　 得：0　　3　　2　　1

一轮结束 打印： 0　　3　　2　　1

i++;　　i=1

 

2.

i=1 j=2　　arr[1]>arr[2]　　条件成立，交换　　 得：0　　2　　3　　1

i=1 j=3　　arr[1]>arr[3]　　条件成立，交换　　 得：0　　1　　3　　2

第二轮结束 打印：0　　1　　3　　2

i++;　　i=2

 

3.

i=2 j=3　　arr[2]>arr[3]　　条件成立，交换　　 得：0　　1　　2　　3

第三轮结束，排序完成

打印：0　　1　　2　　3

贴上我蹩脚的画图

简单排序算法———冒泡排序 算法

 

所以 乱序情况下，个别情况满足交换条件，进行交换操作。

所以平均时间复杂度为O(n^2)

由于冒泡排序的比较方法确定了了，即 (n-1)n/2,这也就限定死了它的时间复杂度。

 

关于其稳定性，冒泡排序是稳定的，不会改变相同元素的相对顺序。

 

扫码关注我们
微信号：SRE实战
拒绝背锅 运筹帷幄