Java冒泡排序：从小到大的几种常见写法

Java冒泡排序：从小到大的几种常见写法，需要具体代码示例

冒泡排序是一种简单的排序算法，它重复地比较相邻的两个元素，并根据大小顺序进行交换，直到整个序列有序。在Java中，冒泡排序有几种常见的写法和优化方式，下面将介绍其中的五种常见写法并提供具体代码实例。

第一种写法：普通的冒泡排序

普通的冒泡排序直接嵌套两层循环，外层循环控制比较的轮数，内层循环进行具体的比较和交换。

public static void bubbleSort1(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - 1 - i; j++) {
            if (arr[j] > arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

第二种写法：优化外层循环

在第一种写法的基础上，如果一轮排序没有进行任何交换，说明数组已经有序，可以提前结束排序。为了实现这个优化，我们可以添加一个标记位来记录是否进行了交换。

public static void bubbleSort2(int[] arr) {
    int n = arr.length;
    boolean swapped;
    for (int i = 0; i < n - 1; i++) {
        swapped = false;
        for (int j = 0; j < n - 1 - i; j++) {
            if (arr[j] > arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
                swapped = true;
            }
        }
        if (!swapped) {
            break;
        }
    }
}

第三种写法：优化内层循环

在第二种写法的基础上，可以发现每轮比较都会将最大的元素“冒泡”到最后。因此，每轮比较内层循环的次数可以逐渐减少。

public static void bubbleSort3(int[] arr) {
    int n = arr.length;
    int lastSwapIndex;
    for (int i = 0; i < n - 1; i++) {
        lastSwapIndex = 0;
        for (int j = 0; j < n - 1 - i; j++) {
            if (arr[j] > arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
                lastSwapIndex = j + 1;
            }
        }
        i = n - lastSwapIndex - 2;
    }
}

第四种写法：优化内外层循环

在第三种写法的基础上，如果数组在某轮比较中未发生交换，说明数组后面的元素已经有序，可以提前结束排序。

public static void bubbleSort4(int[] arr) {
    int n = arr.length;
    int lastSwapIndex, rightBoundary;
    rightBoundary = n - 1;
    for (int i = 0; i < n - 1; i++) {
        lastSwapIndex = 0;
        for (int j = 0; j < rightBoundary; j++) {
            if (arr[j] > arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
                lastSwapIndex = j + 1;
            }
        }
        rightBoundary = lastSwapIndex;
        if (rightBoundary <= 1) {
            break;
        }
    }
}

第五种写法：优化外层循环和内层循环

在第四种写法的基础上，我们可以发现每轮比较都会找到当前轮最大的元素，并将其放到了正确的位置上。因此，我们可以在每轮比较中同时找到最大值和最小值，并进行排序。

public static void bubbleSort5(int[] arr) {
    int n = arr.length;
    int lastSwapIndex, leftBoundary, rightBoundary;
    leftBoundary = 0;
    rightBoundary = n - 1;
    while (leftBoundary < rightBoundary) {
        lastSwapIndex = 0;
        for (int j = leftBoundary; j < rightBoundary; j++) {
            if (arr[j] > arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
                lastSwapIndex = j + 1;
            }
        }
        rightBoundary = lastSwapIndex;
        for (int j = rightBoundary; j > leftBoundary; j--) {
            if (arr[j] < arr[j-1]) {
                int temp = arr[j];
                arr[j] = arr[j-1];
                arr[j-1] = temp;
                lastSwapIndex = j - 1;
            }
        }
        leftBoundary = lastSwapIndex;
    }
}

以上就是五种常见的冒泡排序写法，每种写法都有不同的优化方式，在实际使用时可以根据具体情况选择合适的写法。通过这些优化，可以提高冒泡排序的效率，减少排序时间。

冒泡排序虽然简单，但是对于大规模的数据排序时性能较差。因此，在实际应用中，更常使用更高效的排序算法，如快速排序、归并排序等。