冒泡排序通过重复遍历待排序序列，依次比较相邻元素并在顺序错误时交换位置，使得较大元素逐渐向序列末端移动。该算法名称源于较小元素"浮起"、较大元素"下沉"的视觉效果。

核心操作：元素交换

交换两个相邻元素需要借助临时存储空间。假设存在数组 dataset，其下标 k 与 k+1 处的元素需要互换：

int[] dataset = {23, 45, 12, 67, 34};
int buffer = dataset[k];
dataset[k] = dataset[k + 1];
dataset[k + 1] = buffer;

临时变量 buffer 保存初始值防止数据覆盖，确保交换过程完整无误。

比较逻辑

通过条件语句判断相邻元素是否满足排序要求。对于升序排列，当前元素大于后一元素时触发交换：

if (dataset[idx] > dataset[idx + 1]) {
    // 执行交换操作
}

迭代机制

完成整个序列排序需要多层遍历。每轮遍历将当前未排序部分的最大元素移至正确位置，下一轮遍历范围自动缩减一个元素。对于长度为 n 的数组，共需 n-1 轮比较。

嵌套循环实现该过程，外层控制轮次，内层负责相邻比较：

for (int round = 0; round < data.length - 1; round++) {
    for (int idx = 0; idx < data.length - round - 1; idx++) {
        if (data[idx] > data[idx + 1]) {
            int swapper = data[idx];
            data[idx] = data[idx + 1];
            data[idx + 1] = swapper;
        }
    }
}

完整实现示例

以下代码展示带优化标记的冒泡排序：

public class BubbleSortDemo {
    public static void main(String[] args) {
        int[] sequence = {64, 34, 25, 12, 22, 11, 90};
        System.out.println("原始序列: " + java.util.Arrays.toString(sequence));
        
        performSort(sequence);
        
        System.out.println("排序结果: " + java.util.Arrays.toString(sequence));
    }
    
    static void performSort(int[] arr) {
        for (int pass = 0; pass < arr.length - 1; pass++) {
            boolean swapped = false;
            for (int cursor = 0; cursor < arr.length - pass - 1; cursor++) {
                if (arr[cursor] > arr[cursor + 1]) {
                    int temporary = arr[cursor];
                    arr[cursor] = arr[cursor + 1];
                    arr[cursor + 1] = temporary;
                    swapped = true;
                }
            }
            if (!swapped) break; // 若某轮无交换则提前终止
        }
    }
}

过程追踪

以序列 [64, 34, 25, 12, 22, 11, 90] 为例，每轮结束后的状态如下：

轮次	序列状态
初始	[64, 34, 25, 12, 22, 11, 90]
第1轮	[34, 25, 12, 22, 11, 64, 90]
第2轮	[25, 12, 22, 11, 34, 64, 90]
第3轮	[12, 22, 11, 25, 34, 64, 90]
第4轮	[12, 11, 22, 25, 34, 64, 90]
第5轮	[11, 12, 22, 25, 34, 64, 90]