JavaScript 冒泡法举例

冒泡法是一种简单的排序算法，它的原理是比较相邻的两个元素，如果第一个元素大于第二个元素，就交换它们的位置，否则不变。这样一遍遍地重复，直到所有的元素都按照升序或者降序排列好。

下面是5个JavaScript冒泡法的例子，每个例子中的代码都有详细的注释：
// 例1：使用for循环实现冒泡法
function bubbleSort(arr) {
// 获取数组的长度
let len = arr.length;
// 外层循环控制比较的轮数，每轮比较后最大或者最小的元素会被放到末尾
for (let i = 0; i < len - 1; i++) {
// 内层循环控制每轮比较的次数，每次比较相邻的两个元素并交换位置
for (let j = 0; j < len - i - 1; j++) {
// 如果前一个元素大于后一个元素，就交换它们的位置
if (arr[j] > arr[j + 1]) {
// 使用临时变量存储前一个元素
let temp = arr[j];
// 把后一个元素赋值给前一个元素
arr[j] = arr[j + 1];
// 把临时变量赋值给后一个元素
arr[j + 1] = temp;
}
}
}
// 返回排序后的数组
return arr;
}

// 测试数组
let array = [5,4,3,2,1];
// 调用函数并打印结果
console.log(bubbleSort(array)); // [1,2,3,4,5]

// 例2：使用while循环实现冒泡法
function bubbleSort(arr) {
// 获取数组的长度
let len = arr.length;
// 定义一个标志变量，表示是否发生了交换，默认为false
let swapped = false;

do {
// 每次循环前重置标志变量为false
swapped = false;
// 遍历数组中除了最后一个元素之外的所有元素，并比较相邻两个元素并交换位置
for (let i =0; i < len-1; i++) {
if (arr[i] > arr[i+1]) {
let tmp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = tmp;
swapped=true;
}
}
} while(swapped);
return arr;
}

// 测试数组
let array=[34,2,10,-9];
console.log(bubbleSort(array)); //[ -9 ,2 ,10 ,34 ]

//例3:使用递归实现冒泡法
function bubbleSort(arr) {
// 定义一个变量len，用于表示原始数组的长度
var len=arr.length;
// 如果长度小于等于1，直接返回
if(len<=1){return;}
// for循环，从第0位开始遍历，到最后一位之前，因为没有下一个数可以比较
for(var i=0;i<len-1;i++){
// 比较当前位置和下一个位置的值
if(arr[i]>arr[i+1]){
// 如果当前位置的值大于下一个位置的值，则进行值的交换
var temp=arr[i];
arr[i]=arr[i+1];
arr[i+1]=temp;
}
}
// 递归调用本函数，直到最后一位
bubbleSort(arr.slice(0,len-1));
}
// 定义一个存储5个元素的数组
var array=[5,-8,-9,-7,-6];
// 调用冒泡排序函数，对数组进行排序
bubbleSort(array);
// 输出排序后的结果
console.log(array); //[ -9 ,-8 ,-7 ,-6 ,5 ]

//例4：使用ES6语法实现冒泡法

const bubbleSort = (arr) => {
// 获取数组的长度
let len = arr.length;
// 外层循环控制比较的轮数，每轮比较后最大或者最小的元素会被放到末尾
for (let i = 0; i < len - 1; i++) {
// 内层循环控制每轮比较的次数，每次比较相邻的两个元素并交换位置
for (let j = 0; j < len - i - 1; j++) {
// 如果前一个元素大于后一个元素，就交换它们的位置
if (arr[j] > arr[j + 1]) {
// 使用ES6语法中的解构赋值，不需要临时变量
[arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
}
}
}
// 返回排序后的数组
return arr;
};

// 测试数组
let array = [9,8,7,6,5];
// 调用函数并打印结果
console.log(bubbleSort(array)); // [5,6,7,8,9]

//例5：使用优化后的冒泡法

function bubbleSort(arr) {
var len=arr.length;
var lastExchangeIndex=0;//记录最后一次交换位置
var sortBorder=len-1;//无序数列边界
for(var i=0;i<len;i++){
var flag=true;//有序标记
for(var j=0;j<sortBorder;j++){
if(arr[j]>arr[j+1]){
var temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;

           flag=false;//发生了交换，有序标记为false 
           lastExchangeIndex=j;//更新最后一次交换位置 
       }
   }

   sortBorder=lastExchangeIndex;//更新无序数列边界 

   if(flag){//如果没有发生过交换，说明已经是有序数列，直接结束循环 
       break;
   }

}

return arr;
}

var array=[3,-2,-9,-10];

console.log(bubbleSort(array)); //[ -10 ,-9 ,-2 ,3 ]