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)。

我就來總結一下氣泡排序。

排序的時間複雜度主要是：比較+交換

首先來看下最優情況下 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,這也就限定死了它的時間複雜度。

關於其穩定性，氣泡排序是穩定的，不會改變相同元素的相對順序。