第0个元素开始，依次比较相邻的两个元素，如果前面的元素大于后面的元素，那么将两个元素交换位置。
简单来说就是使用相邻的两个元素依次比较，依次将最大的数放到最后。
这种排序方式就像是将最大的元素一个气泡一样慢慢浮来，所以叫冒泡排序。
同一种排序的计算方式不因编程语言的不同而不同，本篇帖子以java为例：
int[] source = {8, 6, 10, 1, 2, 7, 3};// 要排序的数组
第0轮排序:
- 第一次：8与6比较，8>6,交换位置，得到 6, 8, 10, 1, 2, 7, 3
- 第二次，8与10比较，8<10,不用换位置，得到 6, 8, 10, 1, 2, 7, 3
- 第三次，10与1比较，10>1, 交换位置，得到 6, 8, 1, 10, 2, 7, 3
- 第四次，10与2比较，10>2, 交换位置，得到 6, 8, 1, 2, 10, 7, 3
- 第五次，10与7比较，10>7, 交换位置，得到 6, 8, 1, 2, 7, 10, 3
- 第六次，10与3比较，10>3, 交换位置，得到 6, 8, 1, 2, 7,3,10
第0轮结束后，我们将数组总的最大元素冒泡到了数组的最后面。
第0轮代码实现：
//注意比较次数为source.length - 1次
for (int i = 0; i < source.length - 1; i++) {
//如果前面的元素大于后面的元素
if (source[i] > source[i + 1]) {
//交换位置
int temp = source[i];
source[i] = source[i + 1];
source[i + 1] = temp;
}
}
这里面有个比较次数的问题，试想一下，比较两、2个元素的大小，那么需要比较1次，比较3个元素的大小，需要比较2次。比较N个元素的大小，则需要比较N-1次。
第1轮排序：此时的数据源已经变为6, 8, 1, 2, 7,3,10
在第0轮排序结束以后，我们得到了这样的结果：{6, 8, 1, 2, 7,3,10}，跟原来的数组{8, 6, 10, 1, 2, 7, 3}比较，我们发现数组中最大的数字移动到了数组的最右端，那么，在本轮比较中，10这个元素就不需要再参与比较了，所以本轮需要比较的元素从7个变成了6个，那么比较的次数也变成了5次，即第1轮需要比较的次数为n-1-1次。
比较过程如下：
- 第一次：6与8比较，6<8,不交换位置，得到 6, 8, 1, 2, 7,3,10
- 第二次，8与1比较，8>1,交换位置，得到 6, 1, 8, 2, 7,3,10
- 第三次，8与2比较，8>2, 交换位置，得到 6, 1, 2, 8, 7,3,10
- 第四次，8与7比较，8>7, 交换位置，得到 6, 1, 2,7,8,3,10
- 第五次，8与3比较，8>3, 交换位置，得到 6, 1, 2, 7, 3,8,10
第1轮代码实现：
//注意本轮比较次数为source.length - 1-1次
for (int i = 0; i < source.length - 1-1; i++) {
//如果前面的元素大于后面的元素
if (source[i] > source[i + 1]) {
//交换位置
int temp = source[i];
source[i] = source[i + 1];
source[i + 1] = temp;
}
}
第2轮排序推导过程与第0轮和第1轮相似
整个冒泡排序的代码实现：
/**
* 冒泡排序
*/
public void bubbleSort() {
int[] source = {10, 6, 1, 8, 2, 7, 3};
//外层，用于记录和控制第几轮循环
for (int i = 0; i < source.length - 1; i++) {
//内层，用于控制每轮循环的次数
for (int j = 0; j < source.length - 1 - i; j++) {
//如果前面的数大于后面的数，则交换位置
if (source[j] > source[j + 1]) {
int temp = source[j];
source[j] = source[j + 1];
source[j + 1] = temp;
}
}
}
