大O表示法

通常用大O表示法表示算法的效率

如下图，从左到右，从上到下，效率依次递增

下面看几个算法题对应的时间空间复杂度

时间复杂度：O(1)；空间复杂度：O(1)

时间的消耗和数组长度无关，无论数组多长，时间消耗都是固定的

function(array){
    return array[0]
}

时间复杂度：O(log n)；空间复杂度：O(1)

// 二分法找数
const arr = [1,2,3,4,5,6,7];
const fn = (target)=>{
     let start = 0,end=arr.length-1,middle,ele;
     while(start<=end){
         middle = Math.floor((start+end)/2);
         ele = arr[middle];
         if(ele === target){
             console.log(middle);
             return middle
         } else if(target < ele){
             end = middle-1
         } else {
             start = middle+1
         }
     }
 }
 fn(3)

• 每次查找都会把查找区间缩小一半（start/end/middle）。

• 所以查找次数最多为 log₂(n) 次（n 为数组长度）。

• 详细解释

  • 第一次查找：n 个元素
  • 第二次查找：n/2 个元素
  • 第三次查找：n/4 个元素
  • · · ·
  • 直到只剩 1 个元素

  所以总共查找次数为 log₂(n) 次，时间复杂度为 O(log n)； 因为是循环实现，没有递归调用栈，空间复杂度为 O(1)

时间复杂度：O(n²)； 空间复杂度：O(1)

//选择排序
const arr = [1, 2, 19, 12, 21, 13, 8, 4];

const fn = (arr) => {
  for (let i = 0; i < arr.length; i++) {
      let min = i;
      for (let j = i + 1; j < arr.length; j++) {
          if (arr[j] < arr[min]) {
              min = j;
          }
      }
      [arr[i], arr[min]] = [arr[min], arr[i]];
  }
  return arr;
};
const res = fn(arr);    

• 外层循环遍历数组每个元素 i。

• 内层循环从 i+1 开始，找出最小值索引 min。

• 将当前索引 i 和最小值位置 min 的元素交换。

• 详细解释

  • 时间复杂度

    • 外层循环 ：执行 n 次（n 是数组长度）

    • 里层循环

      • 第一次内层循环：比较 n-1 次
      • 第二次内层循环：比较 n-2 次
      • · · ·
      • 最后一次：比较 1 次

      所以总共查找次数为(n-1)+(n-2)+(n-3)+...次，时间复杂度为 O(n²)。

  • 空间复杂度

    • 只使用了常数级额外空间（几个变量 i, j, min）。

      所以空间复杂度为：O(1)

时间复杂度：O(2ⁿ)；空间复杂度O(n)

//斐波拉契数列
function fn(num) {
    if(num<=2) return 1;
    return fn(num-1)+fn(num-2);
}

可以看到，每次调用都会分出两个子调用，形成一棵二叉树结构。

• 每层节点数量为 $2\; d\; 2^d$2d，其中 d 是深度。

• 总调用次数 ≈ $2\; n\; 2^n$2n

  所以时间复杂度为O(2ⁿ)

递归的空间复杂度取决于最大递归调用栈的深度。

• 最深路径是从 fn(n) → fn(n-1) → fn(n-2) → ... → fn(1)

• 所以最大栈深度是 n

  所以空间复杂度为O(n)