一、冒泡排序（BubbleSort）
- 基本思想：从左到右使用相邻两个元素进行比较，如果第一个比第二个大，则交换两个元素。这样会使较大数下沉到数组的尾端，即较小数像泡泡一样冒到数组首端。
- 排序过程：
- 比较相邻两个元素，如果第一个比第二个大，则交换两个元素；
- 从左到右依次比较，直到最大数位于数组尾端；
- 重复N-1次1、2步骤，(除去已经排序的最大数)依次将第二，第三。。。第N-1大的数排好位置。
| 原序列 | 3 | 9 | 6 | 5 | 8 | 2 | 7 | 4 |
|---|---|---|---|---|---|---|---|---|
| 第1趟 | 3 | 6 | 5 | 8 | 2 | 7 | 4 | 9 |
| 第2趟 | 3 | 5 | 6 | 2 | 7 | 4 | 8 | 9 |
| 第3趟 | 3 | 5 | 2 | 6 | 4 | 7 | 8 | 9 |
| 第4趟 | 3 | 2 | 5 | 4 | 6 | 7 | 8 | 9 |
| 第5趟 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
| 第6趟 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
| 第7趟 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
如表格所示，每一趟都将当前乱序序列中最大的数移到尾端。【小伙伴们从表格中看出基本冒泡排序可以优化的地方了吗？】下面先来基本实现代码。
java实现冒泡排序：
private static <T extends Comparable<? super T>> void bubbleSort(T[] nums) {
if (null == nums || nums.length == 0) {
throw new RuntimeException("数组为null或长度为0");
}
T temp = null;
int length = nums.length;
//外循环是趟数，每一趟都会将未排序中最大的数放到尾端
for (int i = 0; i < length - 1; i++) {
//内循环是从第一个元素开始，依次比较相邻元素，
// 比较次数随着趟数减少，因为每一趟都排好了一个元素
for (int j = 0; j < length - 1 - i; j++) {
if (nums[j].compareTo(nums[j + 1]) > 0) {
temp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = temp;
}
}
}
}
从表格中，相信小伙伴已经看出，在第5趟其实已经排好序了，但基本的冒泡排序算法还会进行第7趟比较，这其实只是进行没必要的比较，而不会进行元素的交换。（第6趟还是必须要走的，下面会说明）
- 时间、空间复杂度及稳定性分析：
时间复杂度：由于内外循环都发生N次迭代，所以时间复杂度为O(n^2)。并且这个界是精确的。思考最坏的情况，输入一个逆序的数组，则比较次数为：
(N-1)+(N-2)+(N-3)+..+2+1 = n*(n-1)/2 = O(n^2)
空间复杂度：只使用了一个临时变量，所以为O(1)；
是否稳定：稳定排序
二、优化冒泡排序
我们换个角度看待这个问题。基本冒泡算法之所以进行了无用的多余扫描，是因为不知道已经排好了序；所以只要我们在第 i 趟（i小于N-1）就知道序列已经排好序，我们就不用进行之后的扫描了。
综上所述，我们可以增加一个boolean变量，来标识是否已经排好序。优化代码如下：
冒泡排序优化普通版：
private static <T extends Comparable<? super T>> void bubbleSort(T[] nums) {
if (null == nums || nums.length == 0) {
throw new RuntimeException("数组为null或长度为0");
}
T temp = null;
int length = nums.length;
//用于标识是否已经将序列排好序
boolean isOrdered = false;
for (int i = 0; i < length - 1; i++) {
//每一趟开始前都假设已经有序
isOrdered = true;
for (int j = 0; j < length - 1 - i; j++) {
if (nums[j].compareTo(nums[j + 1]) > 0) {
temp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = temp;
//如果出现有元素交换，则表明此躺可能没有完成排序
isOrdered = false;
}
}
//如果当前趟都没有进行元素的交换，证明前面一趟比较已经排好序
//直接跳出循环
if (isOrdered) {
break;
}
}
}
注意：虽然第5趟已经排好序，但对于程序来说，它并不知道此趟已经排好序，需要进行下一趟扫描来确定上一趟是否已经将原序列排好序。所以第6趟是必须要去扫描的。
你以为结束了吗？哈哈哈，还没有，这只是第一版优化。
让我们想一想这样的情况。对于下列序列，前半部分乱序，后半部分有序。
| 原序列 | 4 | 5 | 3 | 2 | 6 | 7 | 8 | 9 |
|---|---|---|---|---|---|---|---|---|
| 第一趟 | 4 | 3 | 2 | 5 | 6 | 7 | 8 | 9 |
| 第二趟 | 3 | 2 | 4 | 5 | 6 | 7 | 8 | 9 |
| 第三趟 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
简述排序过程：
第一趟：发生交换的是5和3，接着是5和2；随后5与6比较，不需要换位置，相同地，6与7、7与8、8与9都不需要更换位置。所以第一趟结果为：[4,3,2,5,6,7,8,9]。
第二趟：发生交换的是4与3，接着4与2；随后4与5、5与6，6与7、7与8都不需要更换位置。【8不需要与9比较，因为第一趟已经将最大的数下沉到尾端】。所以第二趟结果为：[3,2,4,5,6,7,8,9]。
第三趟：发生交换的是3与2；随后3与4，4与5，5与6，6与7都不需要更换位置。所以第三趟结果为：[2,3,4,5,6,7,8,9]。
大家看出什么了吗？其实进行了很多无意义的比较，因为这些都不需要更换位置，而很多趟都会重复比较。根据冒泡排序思想，我们知道，有序序列长度，其实跟排序趟数相等，每一趟就是将当前乱序中的最大值下沉到数组尾端。但其实序列真正有序的序列长度是大于当前排序趟数的。也就是说，只要我们找到了原序列中无序与有序的边界，就可以避免再去比较有序序列。
其实最后一次交换的位置，就是无序序列与有序序列的边界。
从例子中看：
第一趟最后一次交换的位置是元素5与2交换的位置，即数组下标2的位置；
第二趟最后一次交换的位置是元素4与2交换的位置，即数组下标1的位置；
第三趟最后一次交换的位置是元素3与2交换的位置，即数组下标0的位置；
所以，只要我们记录下当前趟最后一次交换的位置，在下一趟只比较到这个位置即可。
冒泡排序优化加强版：
private static <T extends Comparable<? super T>> void bubbleSort(T[] nums) {
if (null == nums || nums.length == 0) {
throw new RuntimeException("数组为null或长度为0");
}
T temp = null;
int length = nums.length;
boolean isOrdered = false;
int lastExchangeIndex = 0;
//当前趟无序的边界
int unorderedBorder = length - 1;
for (int i = 0; i < length - 1; i++) {
//每一趟开始前都假设已经有序
isOrdered = true;
for (int j = 0; j < unorderedBorder; j++) {
if (nums[j].compareTo(nums[j + 1]) > 0) {
temp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = temp;
//如果出现有元素交换，则表明此躺没有完成排序
isOrdered = false;
//记录下最后一次交换元素的位置
lastExchangeIndex = j;
}
}
unorderedBorder = lastExchangeIndex;
if (isOrdered) {
break;
}
}
}
其实，还可以进一步优化， 有兴趣的可以去看看鸡尾酒排序，我们已经很接近了。
三、总结
冒泡排序可以通过增加boolean标识是否已经排好序来进行优化；还可以记录下最后一次交换元素的位置来进行优化，防止无意义的比较。冒泡排序是稳定排序，时间复杂度为O(n^2)，空间复杂度为O(1)。