② 时间、空间复杂度计算

01｜📊 时间复杂度

• 定性描述该算法的运行时间，表示算法的运行时间效率

O(1) - 常数时间复杂度

• 执行时间不随数据规模变化
• 示例：简单赋值、算术运算

// 示例1：常量操作
let i = 0
i += 1

// 示例2：数组访问
const arr = [1, 2, 3, 4, 5]
console.log(arr[2])

O(n) - 线性时间复杂度

• 执行时间与数据规模成正比
• 示例：单层循环

// 示例1：遍历数组
for(let i = 0; i < n; i++) {
  console.log(i)
}

// 示例2：查找最大值
let max = arr[0]
for(let i = 1; i < n; i++) {
  if(arr[i] > max) {
    max = arr[i]
  }
}
O(1) + O(n) = O(n)
let i = 0
i += 1
for(let i = 0; i < n; i++) {
  console.log(i)
}

O(n) * O(n) = O(n²) - 平方时间复杂度

• 执行时间与数据规模的平方成正比
• 示例：嵌套循环

// 示例1：双层循环
for(let i = 0; i < n; i++) {
  for(let j = 0; j < n; j++) {
    console.log(i, j)
  }
}

// 示例2：冒泡排序
for(let i = 0; i < n; i++) {
  for(let j = 0; j < n - i - 1; j++) {
    if(arr[j] > arr[j+1]) {
      // 交换元素
    }
  }
}

O(log n) - 对数时间复杂度

• 执行时间随数据规模呈对数增长
• 示例：二分查找、分治算法

// 示例1：二分查找
let i = 1
while(i < n) {
  console.log(i) // 执行次数：log₂n
  i *= 2         // 每次i翻倍
}

// 示例2：二分搜索
function binarySearch(arr, target) {
  let left = 0, right = arr.length - 1
  while(left <= right) {
    const mid = Math.floor((left + right) / 2)
    if(arr[mid] === target) return mid
    if(arr[mid] < target) left = mid + 1
    else right = mid - 1
  }
  return -1
}

02｜💾 空间复杂度

• 算法在运行过程中临时占用存储空间大小的度量，表示算法的内存使用效率

O(1) - 常数空间复杂度

• 使用的额外空间不随数据规模变化

// 示例1：变量交换
let a = 1, b = 2
let temp = a
a = b
b = temp

// 示例2：计算总和
let sum = 0
for(let i = 0; i < n; i++) {
  sum += arr[i]
}

O(n) - 线性空间复杂度

• 使用的额外空间与数据规模成正比

// 示例1：复制数组
const list = []
for(let i = 0; i < n; i++) {
  list.push(i)
}

// 示例2：哈希表存储
const map = new Map()
for(let i = 0; i < n; i++) {
  map.set(i, i * 2) // 存储n个键值对
}

O(n²) - 平方空间复杂度

• 使用的额外空间与数据规模的平方成正比

// 示例：创建二维数组（矩阵）
const matrix = []
for(let i = 0; i < n; i++) {
  matrix.push([])
  for(let j = 0; j < n; j++) {
    matrix[i].push(j)
  }
}

03｜复杂度对比

时间复杂度对比

复杂度	名称	n=10	n=100	n=1000	示例算法
O(1)	常量	1	1	1	数组访问
O(n)	线性	10	100	1000	线性搜索
O(n²)	平方	100	10000	1000000	冒泡排序
O(log n)	对数	～3	～7	～10	二分查找

空间复杂度对比

复杂度	名称	额外存储	适用场景
O(1)	原地算法	固定空间	排序、搜索
O(n)	线性	与输入同规模	哈希表、缓存
O(n²)	平方	二维结构	邻接矩阵、图像处理

04｜学习要点

主题	关键点	记忆技巧
时间复杂度	描述执行时间增长趋势	关注循环嵌套层级
O(1)	常量时间，最佳	无循环，直接访问
O(n)	线性时间，常见	单层循环
O(n²)	平方时间，需优化	双层循环
O(log n)	对数时间，高效	每次数据减半
空间复杂度	描述内存使用增长	关注数据结构大小
O(1)	原地算法	只使用固定变量
O(n)	线性存储	创建数组/哈希表
时间-空间权衡	根据场景选择	缓存 vs 计算