从零开始学算法 - 冒泡排序

冒泡排序的思路：

遍历数组，两两比较，将较大的数字挪到后面。

每一次遍历，最大的数字就像泡泡一样冒到最后。

多次遍历过后，数组的顺序就排好了。

 

用一个长度为10的数组，解释一下冒泡排序：

原始数组：[72, 34, 51, 80, 14, 92, 84, 95, 68, 22]

第一次遍历： 

两两比较：[72, 34, 51, 80, 14, 92, 84, 95, 68, 22]

做出交换：[34, 72, 51, 80, 14, 92, 84, 95, 68, 22]

做出交换：[34, 51, 72, 80, 14, 92, 84, 95, 68, 22]

继续比较：[34, 51, 72, 80, 14, 92, 84, 95, 68, 22]

做出交换：[34, 51, 72, 14, 80, 92, 84, 95, 68, 22]

继续比较：[34, 51, 72, 14, 80, 92, 84, 95, 68, 22]

做出交换：[34, 51, 72, 14, 80, 84, 92, 95, 68, 22]

继续比较：[34, 51, 72, 14, 80, 84, 92, 95, 68, 22]

做出交换：[34, 51, 72, 14, 80, 84, 92, 68, 95, 22]

做出交换：[34, 51, 72, 14, 80, 84, 92, 68, 22, 95]

经过一次遍历，最大的数字95冒泡到了数组的最后边。

重复几次这个过程，整个数组就排好序了。

 

把上述过程翻译成代码：

基本实现：

function popSort(arr){
　　//外循环
　　for(var i=0;i<arr.length-1;i++){
　　　　//内循环
　　　　for(var j=0;j<arr.length-1;j++){
　　　　　　//判断并交换　　
　　　　　　if(array[j]>arr[j+1]){
　　　　　　　　var tmp = arr[j];
　　　　　　　　arr[j] = arr[j+1];
　　　　　　　　arr[j+1] = tmp;
　　　　　　}
　　　　}
　　}
}

 优化一下：

内循环遍历过 i次 后，后面的 i个数字已经排好序，所以内循环可以把这个次数减掉，从而减少内循环的次数。

也可能出现，外循环没有全部走完数组就整体排好序的情况，可以加一个标识判断一下，从而减少外循环的次数。

function popSort(arr){
　　for(var i=0;i<arr.length-1;i++){
　　　　//增加一个标识，判断本次循环有没有进行交换
　　　　var isSort = true;
　　　　//减少内循环的次数
　　　　for(var j=0;j<arr.length-1-i;j++){
　　　　　　if(arr[j]>arr[j+1]){
　　　　　　　　isSort = false;
　　　　　　　　var tmp = arr[j];
　　　　　　　　arr[j] = arr[j+1];
　　　　　　　　arr[j+1] = tmp;
　　　　　　}
　　　　}
　　　　//flag没被修改成false，代表排好了，就跳出循环
　　　　if(flag){
　　　　　　break;
　　　　}
　　}
}