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

/**
* 冒泡排序
* @param arr 待排序的数组
*/
public static void bubbleSort(int[] arr) {
int n = arr.length;
for (int i = 0; i < n - 1; i++) { // 外层循环控制排序轮数
for (int j = 0; j < n - i - 1; j++) { // 内层循环控制每轮排序的次数
if (arr[j] > arr[j + 1]) { // 如果前一个元素比后一个元素大，交换它们的位置
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}

相关问题

public class BubbleSort { public static void bubbleSort(int[] arr) { int n = arr.length; for (int i = 0; i < n-1; i++) { for (int j = 0; j < n-i-1; j++) { if (arr[j] > arr[j+1]) { // swap arr[j+1] and arr[j] int temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; } } } } public static void main(String[] args) { int[] arr = {64, 34, 25, 12, 22, 11, 90}; bubbleSort(arr); System.out.println("Sorted array:"); for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + " "); } }}优化

冒泡排序的时间复杂度为 O(n^2)，如果数据量较大，排序的时间会很慢。下面介绍两种优化方法：

1. 如果在一次外循环中，没有发生任何交换，则说明数组已经有序，可以提前结束排序。

2. 在内循环中，记录最后一次交换的位置，该位置后面的元素已经有序，下一次内循环只需要遍历到这个位置即可。

优化后的代码如下：

public static void bubbleSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        boolean flag = true; // 标记是否发生交换
        int lastIndex = n - 1; // 记录最后一次交换的位置
        for (int j = 0; j < lastIndex; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                flag = false;
                lastIndex = j; // 更新最后一次交换的位置
            }
        }
        if (flag) { // 如果没有发生交换，说明已经有序，提前结束排序
            break;
        }
    }
}

```java public static void bubbleSort(int[] arr) { for (int i = 0; i < arr.length - 1; i++) { for (int j = 0; j < arr.length - 1 - i; j++) { if (arr[j] > arr[j + 1]) { // 如果左边的数大于右边的数，则交换，保证右边的数字最大 int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } } } } ```

这段代码实现了冒泡排序算法，将给定的整型数组按照从小到大的顺序排序。其具体实现过程是，首先循环遍历整个数组，每次将未排序部分中最大的数通过多次交换操作移到已排序部分的末尾。具体来说，内层循环从数组的开头开始遍历到未排序部分的最后一个元素，如果左边的数大于右边的数，则交换这两个数的位置，保证右边的数字最大。内层循环结束后，最大的数就被交换到了未排序部分的末尾，然后外层循环继续遍历未排序部分的前面一个元素，以此类推，直到整个数组都被排序完成。需要注意的是，代码中的交换操作应该是`int temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp;`而不是`int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp;`，因为内层循环的变量是`j`而不是`i`。