冒泡排序Java代碼實現

冒泡排序

冒泡排序是一種簡單的排序算法。它重複地走訪過要排序的數列，一次比較兩個元素，如果它們的順序錯誤就把它們交換過來。

走訪數列的工作是重複地進行直到沒有再需要交換，也就是說該數列已經排序完成。

這個算法的名字由來是因爲越小的元素會經由交換慢慢“浮”到數列的頂端。

算法描述

1. 比較相鄰的元素。如果第一個比第二個大，就交換它們兩個；
2. 對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對，這樣在最後的元素是最大的數；
3. 針對所有的元素重複以上的步驟，除了最後一個；
4. 重複步驟1~3，直到排序完成。

算法分析

• 時間複雜度
  • 最好情況：O(n)
  • 最壞情況：O(n2)
  • 平均情況：O(n2)
• 空間複雜度：O(1)
• 穩定性：穩定

代碼實現

public class BubbleSort {
    public static void bubbleSort(int[] arr) {
        // 空數組 或 只有一個元素的數組，則什麼都不做。
        if (arr == null || arr.length == 1) return;

        // 外層循環表示趟數。
        for (int i = 0; i < arr.length - 1; i++) {

            // 默認有序，如果發生交換說明無序。
            boolean isSorted = true;

            // j 表示 要比較元素對的第一個。
            for (int j = 0; j < arr.length - 1 - i; j++) {
                // 不能寫 >= ，否則不穩定。
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    // 發生交換了，說明無序。
                    isSorted = false;
                }
            }

            // 如果沒有發生交換，則數組已經有序，結束冒泡。
            if (isSorted)   return;

            // 把每一趟排序的結果也輸出一下。
            System.out.print("第 "+ (i+1) + " 趟: ");
            print(arr);
        }
    }

    public static void main(String[] args) {
        int[] arr = {6, 9, 1, 4, 5, 8, 7, 0, 2, 3};

        System.out.print("排序前:  ");
        print(arr);

        bubbleSort(arr);

        System.out.print("排序後:  ");
        print(arr);
    }

    // 打印數組
    public static void print(int[] arr) {
        if (arr == null)    return;

        for(int i : arr) {
            System.out.print(i + " ");
        }
        System.out.println();
    }
}
/*
排序前:  6 9 1 4 5 8 7 0 2 3 
第 1 趟: 6 1 4 5 8 7 0 2 3 9 
第 2 趟: 1 4 5 6 7 0 2 3 8 9 
第 3 趟: 1 4 5 6 0 2 3 7 8 9 
第 4 趟: 1 4 5 0 2 3 6 7 8 9 
第 5 趟: 1 4 0 2 3 5 6 7 8 9 
第 6 趟: 1 0 2 3 4 5 6 7 8 9 
第 7 趟: 0 1 2 3 4 5 6 7 8 9 
排序後:  0 1 2 3 4 5 6 7 8 9
*/