核心思想：
冒泡排序就像「水中的气泡上浮」，每次比较相邻元素，如果顺序不对就交换，把最大的元素一步步推到数组末尾。重复这个过程，直到整个数组有序。
---
📌 分步拆解（以数组 `[5, 3, 8, 1]` 为例）
第一轮冒泡（找出最大值 8）
```
初始数组：[5, 3, 8, 1]
Step 1: 5 vs 3 → 交换 → [3,5,8,1]
Step 2: 5 vs 8 → 不交换
Step 3: 8 vs 1 → 交换 → [3,5,1,8]
结果：最大值 8 沉底 → [3,5,1,8]
```
第二轮冒泡（找出次大值 5）
```
当前数组：[3,5,1,8]
Step 1: 3 vs 5 → 不交换
Step 2: 5 vs 1 → 交换 → [3,1,5,8]
结果：次大值 5 沉底 → [3,1,5,8]
```
第三轮冒泡（找出第三大值 3）
```
当前数组：[3,1,5,8]
Step 1: 3 vs 1 → 交换 → [1,3,5,8]
结果：第三大值 3 沉底 → [1,3,5,8]
```
最终结果：
数组有序 → **[1, 3, 5, 8]**
---
🖥️ Java代码实现
```java
public class BubbleSort {
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[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
public static void main(String[] args) {
int[] arr = {5, 3, 8, 1};
bubbleSort(arr);
System.out.println(Arrays.toString(arr)); // 输出 [1, 3, 5, 8]
}
}
```
---
🎨 图解流程
```
初始数组： [5] [3] [8] [1]
↑ ↑
第一轮比较5和3 → 交换 → [3][5][8][1]
第一轮继续： [5] [8] → 不交换
↑ ↑
第一轮继续： [8] [1] → 交换 → [3][5][1][8]
↑ ↑
第二轮开始： [3][5][1][8]
↑ ↑
第二轮比较3和5 → 不交换
第二轮继续： [5][1] → 交换 → [3][1][5][8]
↑ ↑
```
---
⚙️ 时间复杂度
- **最坏情况**：O(n²)（完全逆序）
- **最佳情况**：O(n)（已有序，可优化提前终止）
---
💡 关键点总结
1. **双重循环**：外层控制轮数，内层遍历比较。
2. **相邻交换**：每次只交换相邻元素。
3. **逐步沉底**：每轮确定一个最大值到末尾。
4. **适用场景**：小规模数据或教学演示（实际开发中效率较低）。