基本思路

  1. 每次对两个值的比较
    1. 前一个比后一个值大就交换位置
    2. 前一个比后一个值小就不动
  2. 每次比较完成后都会把最大的值放到最后面

时间复杂度 

  1. var arr = [5, 2, 3, 1, 4];
  3. let bSort = (arr) => {
  4.     for(let i = 0; i < arr.length - 1; i++) {
  5.       for(let j = 0; j < arr.length - 1; j++) {
  6.         if(arr[j] > arr[j+1]) {
  7.           let swap = arr[j];
  8.         arr[j] = arr[j+1];
  9.         arr[j+1] = swap;
  10.       }
  11.     }
  12.   }
  13.   return arr;
  14. }
  16. console.log(bSort(arr));

优化点

  1. 当外层循环完成一次，内层循环的判断可以为外层循环次数 - 1，已经冒出的值不用再比较
    j < arr.length - i - 1
  2. 如果在某次内层循环中没有交换过值，即说明已经排序好没必要继续比较冒泡
    let flag = false; 如果出现值交换 flag = true; 每次内层循环完成后对 flag 进行判断，如果 flag 还是 false 那么排序已经完成直接 return arr; 
    1. let bSort = (arr) => {
    2.  for(let i = 0; i < arr.length - 1; i++) {
    3.  let flag = false;
    4.    for(let j = 0; j < arr.length - i - 1; j++) {
    5.      if(arr[j] > arr[j+1]) {
    6.        let swap = arr[j];
    7.      arr[j] = arr[j+1];
    8.      arr[j+1] = swap;
    9.      flag = true;
    10.    }
    11.  }
    12.  if(!flag) return arr;
    13. }
    14. return arr;
    15. }