时间复杂度入门：提高代码效率的关键

前言：为什么需要关心时间复杂度？

假设你要在1000本书里找到某一本，有两种方法：

一本一本翻，直到找到为止（可能需要翻1000次）。
先按书名排序，再直接跳到大概的位置（可能只要翻10次）。

第一种方法的时间随着书本数量增加而增长，第二种方法时间增长得很慢。这就是时间复杂度要解决的问题------帮助我们在写代码时，预估数据量变大后程序会不会变慢。

但不仅仅是时间复杂度，空间复杂度也同样重要。它描述了程序执行时所需内存空间的变化趋势。在某些情况下，优化空间复杂度能够极大地提高程序的整体性能。

一、时间复杂度是什么？

简单说：时间复杂度描述的是"当数据量变大时，程序运行时间增长的趋势"。

比如：

一个班级有50人，老师点名需要喊50次名字（时间与人数成正比"O(n)"）。
无论班级有多少人，老师看一眼座位表就知道总人数（时间固定"O(1)"）。

我们不用计算具体秒数，而是看数据量（n）增加时，操作次数如何变化。

二、5种常见时间复杂度对比

1. O(1)：固定时间（最快）

java 复制代码

// 直接获取数组第一个元素
public static int getFirst(int[] arr) {
    return arr[0]; // 无论数组多长，只做一次操作
}

例子：用钥匙开锁，无论钥匙串有多少把钥匙，找到正确的那把就能开锁。

补充：O(1)代表的是常数时间，最理想的情况。这类操作的执行时间与输入规模无关。

2. O(n)：时间与数据量成正比

java 复制代码

// 计算数组所有元素的和
public static int sumArray(int[] nums) {
    int sum = 0;
    for (int num : nums) { // 数组有n个数，循环n次
        sum += num;
    }
    return sum;
}

例子：超市结账时，10件商品需要扫描10次。

补充：O(n)的复杂度表示操作次数与数据量呈线性关系，数据量增加时，时间也会等比例增加。虽然是比较常见的情况，但还是要考虑能否优化。

3. O(n²)：时间成平方增长（慎用）

java 复制代码

// 打印所有两两组合
public static void printPairs(int n) {
    for (int i = 0; i < n; i++) {     // 外层循环n次
        for (int j = 0; j < n; j++) { // 内层循环n次
            System.out.println(i + "-" + j); // 总共打印n*n次
        }
    }
}

例子：10个同学两两握手，需要握45次（10*9/2），接近n²次。

补充：当数据量增加时，O(n²)的时间增长非常迅速。避免使用此类算法，除非数据量较小或对性能要求不高。

4. O(log n)：时间增长缓慢（高效）

java 复制代码

// 二分查找（数组必须已排序）
public static int binarySearch(int[] arr, int target) {
    int left = 0, right = arr.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] == target) return mid;
        if (arr[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1; // 最多执行log₂(n)次循环
}

例子：翻字典找单词，1000页的字典最多翻10次（2^10=1024）。

补充：O(log n)表示时间复杂度随输入数据的增长而以对数方式增加。通过每次迭代将数据范围减少一半，效率非常高。

5. O(2ⁿ)：时间爆炸增长（尽量避免）

java 复制代码

// 递归计算斐波那契数列
public static int fib(int n) {
    if (n <= 1) return n;
    return fib(n-1) + fib(n-2); // 每次调用分裂成两次递归
}

例子：尝试破解4位密码，需要测试0000到9999共10000种组合（10^4）。

补充：O(2ⁿ)的复杂度会随着输入规模急剧增长。对于大规模输入，程序几乎不可行。可以考虑使用动态规划 或尾递归优化。

三、如何分析一段代码的时间复杂度？

步骤1：找到最耗时的操作

看代码中哪部分重复执行最多次。通常是循环或递归里的代码。

java 复制代码

for (int i = 0; i < n; i++) {      // 外层循环n次
    for (int j = 0; j < i; j++) {  // 内层循环次数逐渐增加
        System.out.println(j);     // 这是核心操作
    }
}

步骤2：计算操作次数

把循环次数转化成数学公式：

当i=0时，内层循环执行0次
当i=1时，执行1次
...
当i=n-1时，执行n-1次

总次数 = 0 + 1 + 2 + ... + (n-1) = n(n-1)/2

步骤3：简化表达式

去掉常数，只留最高次项：n(n-1)/2 → n²

所以上面的代码时间复杂度是 O(n²)。

步骤4：注意特殊结构

循环变量翻倍：

java 复制代码

int i = 1;
while (i < n) {
    i *= 2;  // 循环次数是log₂(n)
}

递归调用：斐波那契数列的递归写法会产生指数级操作次数。

四、为什么时间复杂度重要？

假设处理100万条数据（n=1,000,000）：

O(n) 的算法需要约1秒（假设每次操作1纳秒）。
O(n²) 的算法需要约11.5天。
O(2ⁿ) 的算法可能需要亿万倍。

这就是为什么：

数据库用O(log n)的B+树结构快速查找。
地图软件用O(n²)的动态规划算法时，只能处理少量地点。
网站后端要避免使用递归处理大数据。

结语：学会用时间复杂度思考

下次写代码时，试着问自己三个问题：

这段代码最耗时的操作是什么？
如果数据量翻倍，运行时间会变成几倍？
有没有更高效的方法？

比如：

遍历数组查找用O(n)，换成哈希表查找可以变成O(1)
双重循环处理数据用O(n²)，先排序可能优化到O(n log n)

最后：不是所有代码都要追求最快，但一定要避免写出让程序卡死的代码。