Java 數組排序算法實戰：冒泡排序完整代碼與優化

冒泡排序核心邏輯

通過相鄰元素比較交換，每輪將最大值「冒泡」到末尾。時間複雜度 O(n²)，空間 O(1)，**穩定排序**。適合教學、小規模數據或近乎有序數據。

標準實現

public class ArraySort {
    /** 冒泡排序 (升序) */
    public static int[] bubbleSort(int[] arr) {
        if (arr == null || arr.length <= 1) return arr;
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            boolean swapped = false; // 優化標記
            for (int j = 0; j < n - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;
                    swapped = true;
                }
            }
            if (!swapped) break; // 本輪無交換，已有序，提前結束
        }
        return arr;
    }

    /** 打印數組 */
    public static void printArray(int[] arr) {
        for (int v : arr) System.out.print(v + " ");
        System.out.println();
    }

    public static void main(String[] args) {
        int[] a = {12, 24, 25, 4, 9, 68, 45, 7};
        System.out.println("排序前：");
        printArray(a);
        bubbleSort(a);
        System.out.println("排序後：");
        printArray(a);
    }
}

執行結果

排序前：
12 24 25 4 9 68 45 7
排序後：
4 7 9 12 24 25 45 68

進階優化：雞尾酒排序 (雙向冒泡)

public static void cocktailSort(int[] arr) {
    int left = 0, right = arr.length - 1;
    while (left < right) {
        // 正向冒泡，最大值到 right
        for (int i = left; i < right; i++)
            if (arr[i] > arr[i+1]) swap(arr, i, i+1);
        right--;
        // 反向冒泡，最小值到 left
        for (int i = right; i > left; i--)
            if (arr[i] < arr[i-1]) swap(arr, i, i-1);
        left++;
    }
}

減少「烏龜」 (小數值在右端) 緩慢移動的問題，近乎有序時更快。

生產環境建議

• **直接用 Arrays.sort()** (雙軸快排/併歸排序混合)，性能極優、經過充分測試。
• **基本類型用 Arrays.parallelSort()** (Java 8+) 多線程並行排序大數組。
• **對象數組用 List.sort(Comparator)** 或 Arrays.sort(T[], Comparator)。
• 自定義排序僅用於教學、特殊約束 (如外部排序、計數排序) 場景。

總結

冒泡排序理解「比較交換、逐輪收斂、穩定性」的絕佳入門。掌握 swapped 優化與雙向改進，面試手寫無壓力。實際開發**堅決使用標準庫**。