Java中冒泡排序的优化方法

1. 引言

冒泡排序（Bubble Sort）是一种简单的排序算法，它通过重复地遍历待排序的列表，比较相邻的元素并交换它们的位置来实现排序。该算法的名称来源于较小的元素会像"气泡"一样逐渐"浮"到列表的顶端。

2. 算法步骤

比较相邻元素：从列表的第一个元素开始，比较相邻的两个元素。

交换位置：如果前一个元素比后一个元素大，则交换它们的位置。

重复遍历：对列表中的每一对相邻元素重复上述步骤，直到列表的末尾。这样，最大的元素会被"冒泡"到列表的最后。

3. 基础实现

private static int[] bubbleSort(int[] arr) {
        int temp;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j + 1] < arr[j]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        return arr;
    }

4. 优化方法

4.1 添加标志位优化

private static int[] bubbleSortOptimized(int[] arr) {
    int temp;
    boolean swapped;
    for (int i = 0; i < arr.length - 1; i++) {
        swapped = false;
        for (int j = 0; j < arr.length - 1 - i; j++) {
            if (arr[j + 1] < arr[j]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                swapped = true;
            }
        }
        // 如果这一轮没有发生交换，说明已经有序
        if (!swapped) break;
    }
    return arr;
}

4.2 记录最后交换位置优化

private static int[] bubbleSortAdvanced(int[] arr) {
    int temp;
    int lastSwapIndex = arr.length - 1;
    int currentSwapIndex;
    
    for (int i = 0; i < arr.length - 1; i++) {
        currentSwapIndex = -1;
        for (int j = 0; j < lastSwapIndex; j++) {
            if (arr[j + 1] < arr[j]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                currentSwapIndex = j;
            }
        }
        // 如果这一轮没有交换，提前结束
        if (currentSwapIndex == -1) break;
        // 记录最后一次交换的位置，后面的已经有序
        lastSwapIndex = currentSwapIndex;
    }
    return arr;
}

4.3 鸡尾酒排序（双向冒泡）

private static int[] cocktailSort(int[] arr) {
    int temp;
    int left = 0;
    int right = arr.length - 1;
    
    while (left < right) {
        boolean swapped = false;
        
        // 从左到右
        for (int i = left; i < right; i++) {
            if (arr[i] > arr[i + 1]) {
                temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
                swapped = true;
            }
        }
        right--;
        if (!swapped) break;
        
        swapped = false;
        // 从右到左
        for (int i = right; i > left; i--) {
            if (arr[i] < arr[i - 1]) {
                temp = arr[i];
                arr[i] = arr[i - 1];
                arr[i - 1] = temp;
                swapped = true;
            }
        }
        left++;
        if (!swapped) break;
    }
    return arr;
}

4.4 综合优化版本（标志位优化 +记录最后交换位置优化）

private static int[] bubbleSortUltimate(int[] arr) {
    if (arr == null || arr.length <= 1) return arr;
    
    int temp;
    int lastSwapIndex = arr.length - 1;
    int currentSwapIndex;
    
    for (int i = 0; i < arr.length - 1; i++) {
        currentSwapIndex = -1;
        boolean swapped = false;
        
        for (int j = 0; j < lastSwapIndex; j++) {
            if (arr[j] > arr[j + 1]) {
                // 交换元素
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                
                swapped = true;
                currentSwapIndex = j;
            }
        }
        
        // 如果没有交换，提前结束
        if (!swapped) break;
        // 更新最后交换位置
        if (currentSwapIndex >= 0) {
            lastSwapIndex = currentSwapIndex;
        }
    }
    return arr;
}