冒泡排序及相关算法

算法快慢通常由两个纬度来进行比较，时间复杂度，空间复杂度

• 时间复杂度：时间复杂度表示算法的快慢，冒泡排序的时间复杂度是O(N2)
  常见的时间复杂度由O(1),O(N),O(logN),O(NlogN),O(N2),O(N3)
• 空间复杂度：空间复杂度表示该算法实现需要多少个辅助堆栈空间，冒泡排序不需要额外的辅助空间

// 冒泡排序1
let arr = [2, 4, 1, 5, 3]
    let bubbleSort = (arr) => {
      // debugger
      for (let i = 0; i < arr.length - 1; i++) {
        // console.log('i' , arr[i]);
        // 轮
        for (let j = 0; j < arr.length - 1 - i; j++) {
          // console.log('j' , arr[j]);
          // 0 - 4
          // 次
          if (arr[j] > arr[j + 1]) {
            // 交换变量
            // 解构赋值
            [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]]
          }
        }
      }
      return arr
    }
    console.log(bubbleSort(arr));
// 结果 1， 2， 3， 4， 5

补充:解构赋值

// 将a, b两个变量的值交换
    // es5
    var a = 1 ,b = 3
    var temp = ''
    temp = a // 1
    a = b // 3
    b = temp // 1
    console.log(a, b); // 3, 1

    // es 6 
    let a = 1
    let b = 3
    new Promise((resolve) => {
      [a, b] = [b, a]
      resolve()
    }).then((res) => {
      console.log(a, b);
    })

相关算法
1到100，如何求和？
代码的效率和代码执行的行数一般呈现一种正相关的关系
判断代码运行效率， 往往观察其中最短的短板即可

    // 1
    // 时间复杂度为O(n), 数据量越大，速度越慢
    let sum = 1, n = 100 // 执行一次
    for (let i = 1; i <= n; i++){ // 执行了n次
      sum = sum + i
    }
    console.log(sum); // 执行一次

    // 2
    // 时间复杂度为O(1),执行速度不受数据量的影响，是最完美的时间复杂度的情况
    let sum = 0, n = 100 // 执行一次
    sum = (1 + n) * n / 2 // 执行一次
    console.log(sum); // 执行一次