Java冒泡排序

冒泡排序是一种简单的排序算法，它通过比较和交换相邻元素的方式，使得列表中的元素逐渐移动到正确的位置。具体步骤如下：

1. 从列表的第一个元素开始，比较它与下一个元素的大小。
2. 如果顺序不对（前面的元素大于后面的元素），则交换这两个元素的位置。
3. 继续比较和交换下一对相邻元素，直到列表末尾。
4. 重复上述步骤，每次都将最大的元素移动到列表的最后，直到整个列表有序。

下面是用Java实现冒泡排序的示例代码：

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]) {
                    // 交换 arr[j] 和 arr[j + 1] 的位置
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    // 优化后的冒泡排序，增加了一个标志位，减少不必要的比较
    public static void optimizedBubbleSort(int[] arr) {
        int n = arr.length;
        boolean swapped;
        for (int i = 0; i < n - 1; i++) {
            swapped = false;
            for (int j = 0; j < n - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    // 交换 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 main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        
        // 普通冒泡排序
        bubbleSort(arr);
        System.out.println("普通冒泡排序后的数组:");
        printArray(arr);

        // 优化后的冒泡排序
        int[] arr2 = {64, 34, 25, 12, 22, 11, 90};
        optimizedBubbleSort(arr2);
        System.out.println("优化后的冒泡排序后的数组:");
        printArray(arr2);
    }

    // 打印数组
    public static void printArray(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
}

这里提供了两个版本的冒泡排序实现：普通冒泡排序和优化后的冒泡排序。在优化后的版本中，增加了一个标志位 swapped，用于判断是否发生了交换，如果没有发生交换则说明数组已经有序，可以提前退出循环，从而减少不必要的比较。