演算法實現

1. 比較相鄰的元素。如果前一個元素比後一個元素大，就交換這兩個元素的位置。
2. 對每一對相鄰元素做同樣的工作，從開始第一對元素到結尾的最後一對元素。最終最後位置的元素就是最大值。

演算法實現：

/**
 * 氣泡排序
 * @author wen.jie
 * @date 2021/8/4 17:10
 */
public class Bubble {

    /**
     * 排序
     * @author wen.jie
     * @date 2021/8/4 17:28
     */
    public static void sort(Comparable<?>[] a) {
        for (int i = a.length-1; i>0; i--) {
            for (int j = 0; j < i; j++) {
                if (greater(a[j], a[j+1])){
                    exchange(a, j, j+1);
                }
            }
        }
    }

    /**
     * 比較
     * @author wen.jie
     * @date 2021/8/4 17:18
     */
    private static boolean greater(Comparable v, Comparable w) {
        return v.compareTo(w) > 0;
    }

    /**
     * 交換
     * @author wen.jie
     * @date 2021/8/4 17:27
     */
    private static void exchange(Comparable[] a, int i, int j) {
        Comparable temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

}
 

測試：

/**
 * @author wen.jie
 * @date 2021/8/4 17:12
 */
public class BubbleTest {

    @Test
    public void test1(){
        Integer[] arr = {5,4,2,3,6,1};
        Bubble.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

時間複雜度分析

氣泡排序使用了雙層for迴圈，其中內層迴圈的迴圈體是真正完成排序的程式碼，所以， 我們分析氣泡排序的時間複雜度，主要分析一下內層迴圈體的執行次數即可。

在最壞情況下，也就是假如要排序的元素為{6,5,4,3,2,1}逆序，那麼：

元素比較的次數為：(N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;

元素交換的次數為：(N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2；（最壞情況下，每一次比較都會交換）

總執行次數為：(N^2/2-N/2)+(N^2/2-N/2)=N^2-N

按照大O推導法則，保留函式中的最高階項那麼最終氣泡排序的時間複雜度為O(N^2).