冒泡排序的核心是一个嵌套的两层循环，每进行一次外层循环，就把尚未排序的数中的最大值（降序排序）或者最小值（升序排序）移到外层循环当前索引所在的位置。因为这个过程像是气泡一样上升，因此得名冒泡排序。
使用冒泡排序对 5、6、2、0、5 这五个数（count = 5）进行升序排序，因为每次排序都是前后两个数进行比较，所以外层循环需要进行 count - 1 = 5 - 1 = 4 次（索引为 0 ~3）。内层循环索引 j 从外层循环当前索引位置 i 的下一个索引 i + 1 开始参与比较，结束于 count - 1 = 5 - 1 = 4（也就是索引到 4 的位置，包含索引 4）。整个过程如下所示：
| 外层循环索引 | 内层循环索引 | 当前内层循环结束之后的排序 |
|---|---|---|
| - | - | 5 6 2 0 5 |
| 0 | 1 | 5 6 2 0 5 |
| 0 | 2 | 2 6 5 0 5 |
| 0 | 3 | 0 6 5 2 5 |
| 0 | 4 | 0 6 5 2 5 |
| 1 | 2 | 0 5 6 2 5 |
| 1 | 3 | 0 2 6 5 5 |
| 1 | 4 | 0 2 6 5 5 |
| 2 | 3 | 0 2 5 6 5 |
| 2 | 4 | 0 2 5 6 5 |
| 3 | 4 | 0 2 5 5 6 |
代码实现如下：
- 冒泡排序
public class BubbleSort {
public static void main(String[] args) {
int[] data = new int[] {5, 6, 2, 0, 5};
sort(data);
for (int i = 0, size = data.length; i < size; i++) {
System.out.println(data[i]);
}
}
public static void sort(int[] data) {
for (int i = 0, iCount = data.length - 1; i < iCount; i++) {
for (int j = i + 1, jCount = data.length; j < jCount; j++) {
if (data[i] > data[j]) {
int temp = data[i];
data[i] = data[j];
data[j] = temp;
}
}
}
}
}
运行结果：
0
2
5
5
6
冒泡排序的时间复杂度为 O((N - 1) + (N - 2) + ... + 1) = O((N * (N - 1)) / 2) = O(N^2)。
