冒泡排序 冒泡排序是入门级的算法，但也有一些有趣的玩法。通常来说，冒泡排序有三种写法：
一边比较一边向后两两交换，将最大值 / 最小值冒泡到最后一位； 经过优化的写法：使用一个变量记录当前轮次的比较是否发生过交换，如果没有发生交换表示已经有序，不再继续排序； 进一步优化的写法：除了使用变量记录当前轮次是否发生交换外，再使用一个变量记录上次发生交换的位置，下一轮排序时到达上次交换的位置就停止比较。 冒泡排序的第一种写法 代码如下：
最外层的 for 循环每经过一轮，剩余数字中的最大值就会被移动到当前轮次的最后一位，中途也会有一些相邻的数字经过交换变得有序。总共比较次数是 (n-1)+(n-2)+(n-3)+…+1(n−1)+(n−2)+(n−3)+…+1。
function bubble_sort(arr){
for(let i=0;i<arr.length-1;i++){
for(let j=0;j<arr.length-1-i;j++){
if(arr[j]>arr[j+1]){
// 如果左边的数大于右边的数，则交换，保证右边的数字最大
let temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
这种写法相当于相邻的数字两两比较，并且规定：“谁大谁站右边”。经过 n-1n−1 轮，数字就从小到大排序完成了。整个过程看起来就像一个个气泡不断上浮，这也是“冒泡排序法”名字的由来。
冒泡排序的第二种写法 第二种写法是在第一种写法的基础上改良而来的：
js
function bubble_sort(arr){
let swapped=true,
j=0;
debugger;
while(swapped){
swapped=false;
for(let i=0;i<arr.length-1-j;i++){
if(arr[i]>arr[i+1]){
let temp=arr[i];
arr[i]=arr[i+1];
arr[i+1]=temp;
swapped=true;
}
}
j++;
}
}
这种写法相对于第一种写法的优点是：如果一轮比较中没有发生过交换，则立即停止排序，因为此时剩余数字一定已经有序了。
冒泡排序的第三种写法 第三种写法比较少见，它是在第二种写法的基础上进一步优化：
经过再一次的优化，代码看起来就稍微有点复杂了。最外层的 while 循环每经过一轮，剩余数字中的最大值仍然是被移动到当前轮次的最后一位。
function bubble_sort(arr){
let swapped = true,
lastswapIndex=arr.length-1,
swappedindex=-1;
while(swapped){
swapped=false;
for(let i=0;i<lastswapIndex;i++){
if(arr[i]>arr[i+1]){
swap(arr,i,i+1)
swappedindex=i;
swapped=true;
}
}
lastswapIndex=swappedindex;
}
}
function swap(arr,l,r){
let temp = arr[l];
arr[l]=arr[r];
arr[r]=temp;
}
在下一轮比较时，只需比较到上一轮比较中，最后一次发生交换的位置即可。因为后面的所有元素都没有发生过交换，必然已经有序了。
当一轮比较中从头到尾都没有发生过交换，则表示整个列表已经有序，排序完成。
测试：
Java
public void test() {
int[] arr = new int[]{6, 2, 1, 3, 5, 4};
bubbleSort(arr);
// 输出: [1, 2, 3, 4, 5, 6]
System.out.println(Arrays.toString(arr));
}
*附：交换的技巧
一般来说，交换数组中两个数字的函数如下：
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
但在大厂面试中，有一道非常经典的数字交换题目：如何在不引入第三个中间变量的情况下，完成两个数字的交换。
这里可以用到一个数学上的技巧：
arr[j + 1] = arr[j + 1] + arr[j];
arr[j] = arr[j + 1] - arr[j];
arr[j + 1] = arr[j + 1] - arr[j];
除了这种先加后减的写法，还有一种先减后加的写法：
Java
arr[j + 1] = arr[j] - arr[j + 1];
arr[j] = arr[j] - arr[j + 1];
arr[j + 1] = arr[j + 1] + arr[j];
但这两种方式都可能导致数字越界。
更好的方案是通过位运算完成数字交换：
arr[i] = arr[i] ^ arr[j];
arr[j] = arr[j] ^ arr[i];
arr[i] = arr[i] ^ arr[j];
时间复杂度 & 空间复杂度 冒泡排序从 1956 年就有人开始研究，之后经历过多次优化。它的空间复杂度为 O(1)O(1)，时间复杂度为 O(n^2)O(n 2 )，第二种、第三种冒泡排序由于经过优化，最好的情况下只需要 O(n)O(n) 的时间复杂度。
最好情况：在数组已经有序的情况下，只需遍历一次，由于没有发生交换，排序结束。
最差情况：数组顺序为逆序，每次比较都会发生交换。
但优化后的冒泡排序平均时间复杂度仍然是 O(n^2)O(n 2 )，所以这些优化对算法的性能并没有质的提升。正如 Donald E. Knuth（19741974 年图灵奖获得者）所言：“冒泡排序法除了它迷人的名字和导致了某些有趣的理论问题这一事实外，似乎没有什么值得推荐的。”
