思路： 相邻的数据比较，若不符合顺序则互相交换位置
通俗来说就是j和j+1打，打赢的去后面

基本实现: 时间复杂度O(n^2)

  1. function betterBubbleSort(arr) {
  2.     const len = arr.length  
  3.     for(let i=0;i<len;i++) {
  4.         // 注意差别在这行，我们对内层循环的范围作了限制
  5.         for(let j=0;j<len-1-i;j++) {
  6.             if(arr[j] > arr[j+1]) {
  7.                 [arr[j], arr[j+1]] = [arr[j+1], arr[j]]
  8.             }
  9.         }
  10.     }
  11.     return arr
  12. }

冒泡排序时间复杂度在最好情况下是 O(n)”的实现。

即它对应的是数组本身有序这种情况。在这种情况下，我们只需要作比较（n-1 次），而不需要做交换。时间复杂度为 O(n)
思路：增加一个标志位

  1. function betterBubbleSort(arr) {
  2.     const len = arr.length  
  4.     for(let i=0;i<len;i++) {
  5.         // 区别在这里，我们加了一个标志位
  6.         let flag = false
  7.         for(let j=0;j<len-1-i;j++) {
  8.             if(arr[j] > arr[j+1]) {
  9.                 [arr[j], arr[j+1]] = [arr[j+1], arr[j]]
  10.                 // 只要发生了一次交换，就修改标志位
  11.                 flag = true
  12.             }
  13.         }
  15.         // 若一次交换也没发生，则说明数组有序，直接放过
  16.         if(flag == false)  return arr;
  17.     }
  18.     return arr
  19. }