算法复杂度：时间与空间的权衡之道
在编程与算法设计的世界里，衡量一个算法的优劣绝非仅凭 “能否实现功能”，更核心的标尺是时间复杂度与空间复杂度。前者关乎算法执行效率，后者关乎内存资源消耗，二者共同决定了算法在不同场景下的适用性。本文将结合实际代码示例，深入浅出地解析这两大核心概念。
一、算法复杂度：评价算法的核心维度
一个优秀的算法，既要 “跑得快”，也要 “吃得少”—— 这里的 “快” 对应时间复杂度，衡量算法执行时间随输入规模增长的变化趋势；“少” 对应空间复杂度，衡量算法运行过程中临时占用的存储空间大小。
不同于单纯统计代码执行的毫秒数（受硬件、环境影响），复杂度分析采用 “大 O 表示法（O ()）”，聚焦输入规模n增大时，时间 / 空间消耗的增长趋势，而非具体数值。这意味着我们只需抓住 “主要矛盾”，忽略常数、低阶项等对趋势无影响的部分。
二、时间复杂度：算法的 “执行效率标尺”
1. 时间复杂度的计算逻辑
时间复杂度的计算核心是统计代码执行次数的表达式T(n)，再提炼出其增长趋势。例如，一行固定执行的代码执行次数为 1（T(1)），循环执行n次的代码执行次数为n（T(n)）。最终的时间复杂度，是对T(n)做 “简化”：忽略常数、低阶项，只保留最高阶项。
2. 常见时间复杂度与代码示例
（1）线性时间复杂度 O (n)
当算法执行时间随输入规模n呈线性增长时，时间复杂度为O(n)。
示例代码：
// T(n)
function traverse(arr){
var len = arr.length; // T(1)
for(var i=0;i<len;i++){ // T(1) + T(n+1) + T(n)
console.log(arr[i]); // T(n)
}
}
// T(n) = 1 + 1 + n + 1 + n + n = 3n + 3
这段代码中，traverse函数遍历一维数组，执行次数的表达式为3n+3。由于常数3和低阶项不影响增长趋势，因此时间复杂度简化为O(n)—— 输入规模n越大，执行时间线性增加。
（2）平方时间复杂度 O (n²)
嵌套循环是典型的O(n²)场景，执行次数随输入规模呈平方级增长。
示例代码：
function traverse(arr) {
var outlen = arr.length; // 1
for(var i=0;i<outlen;i++){ // 循环控制相关执行次数：n + 1 + n
var inlen = arr[i].length; // n
for(var j=0;j<inlen;j++){ // 嵌套循环控制：n*(n+1) + n + n*n
console.log(arr[i][j]); // n*n
}
}
}
// 总执行次数 T(n) = 3n² + 5n + 1 → 时间复杂度 O(n²)
二维数组的嵌套遍历中，执行次数表达式为3n²+5n+1，最高阶项为n²，因此时间复杂度为O(n²)。这类算法的执行时间会随n增大快速上升，需谨慎使用。
（3）对数时间复杂度 O (logn)
对数时间复杂度是高效算法的典型特征，执行次数随输入规模呈对数增长。
示例代码：
for(var i=1;i<length;i=i*2){
console.log(arr[i]);
}
这段代码中，循环变量i以 “乘以 2” 的方式增长，循环次数为log₂(n)（n为length）。例如，当length=8时，i依次为 1、2、4，仅循环 3 次；length=16时，循环 4 次。因此时间复杂度为O(logn)，这类算法效率远高于线性时间。
3. 常见时间复杂度等级
从高效到低效，常见时间复杂度排序为：O(1) < O(logn) < O(n) < O(nlogn) < O(n²) < O(n³) < O(2ⁿ)
三、空间复杂度：算法的 “内存消耗标尺”
空间复杂度衡量算法运行过程中临时占用的存储空间大小，同样采用大 O 表示法，核心关注 “额外开辟” 的内存，而非输入参数本身占用的空间。
1. 常数空间复杂度 O (1)
若算法运行过程中无额外内存开销，仅使用固定数量的变量，则空间复杂度为O(1)。
例如 1.js 中的traverse函数：函数接收的参数arr是输入本身，并非临时开辟的空间；函数内仅定义了len、i等固定变量，无额外数组、对象等内存分配，因此空间复杂度为O(1)。
2. 线性空间复杂度 O (n)
当算法临时开辟的存储空间随输入规模n线性增长时，空间复杂度为O(n)。
示例代码：
function init(n) {
var arr = []; // 新开辟 O(n) 空间
for(var i=0;i<n;i++){
arr[i]=i;
}
return arr;
}
init函数中，新创建了长度为n的数组arr，该数组是为实现功能临时开辟的内存，且空间大小随n线性增长，因此空间复杂度为O(n)。
四、总结：时间与空间的权衡
算法设计的核心之一，是在时间复杂度与空间复杂度之间找到平衡：
- 若追求执行速度，可牺牲部分内存（如用 “空间换时间”，例如缓存优化）；
- 若内存资源受限，需优化空间开销（如用 “时间换空间”，例如避免额外数组开辟）。
理解时间复杂度与空间复杂度的计算逻辑，掌握O(1)、O(logn)、O(n)、O(n²)等核心复杂度类型，能帮助我们设计出更高效、更适配场景的算法，也是从 “会写代码” 到 “写好代码” 的关键一步。
