一、钓鱼比赛：为什么方法比努力更重要
有一天，Alice 和 Bob 参加钓鱼比赛，规则是谁先钓到 10 条鱼谁赢。两人来到湖边，采取了不同的策略：
-
Alice 的方法：用渔网一次性捞起 10 条鱼
-
Bob 的方法：用鱼竿一条一条钓，每次钓 1 条
假设捞一次鱼需要 10 秒，钓一条鱼需要 5 秒。当目标是 10 条鱼时：
-
Alice 的总时间：10 秒（无论目标多少，时间不变）
-
Bob 的总时间：10 条 × 5 秒 = 50 秒（时间随目标增加而增加）
如果比赛目标改为 100 条鱼：
-
Alice 仍然只需要 10 秒
-
Bob 需要：100 条 × 5 秒 = 500 秒
这就是时间复杂度的本质：
算法的执行时间如何随数据量的增加而变化。
二、常见时间复杂度的故事比喻
1. O (1)：直接开保险柜
有一个保险柜，密码是固定的1234。无论里面放了 1 块钱还是 100 万，打开它的时间都是一样的：
java
public class Safe {
private static final String PASSWORD = "1234";
public boolean open(String password) {
return password.equals(PASSWORD); // 无论密码多长，比较一次即可
}
}
时间复杂度：O(1)
特点：执行时间与数据量无关，像直接打开保险柜一样快。
2. O (n)：挨个检查快递包裹
快递员要检查一车包裹，每个包裹都需要扫描条形码。包裹越多，花费的时间越长：
java
public class DeliveryMan {
public boolean checkAllPackages(Package[] packages, String targetBarcode) {
for (Package pkg : packages) { // 遍历每个包裹
if (pkg.getBarcode().equals(targetBarcode)) {
return true;
}
}
return false;
}
}
时间复杂度：O(n)
特点：执行时间与数据量成线性关系，包裹越多，时间越长。
3. O (n²)：两两握手的派对
派对上每个人都要和其他所有人握手。如果有 n 个人，握手次数是n × (n-1)/2：
java
public class Party {
public int countHandshakes(int peopleCount) {
int count = 0;
for (int i = 0; i < peopleCount; i++) { // 第一个人
for (int j = i + 1; j < peopleCount; j++) { // 其他所有人
count++; // 握手一次
}
}
return count;
}
}
时间复杂度：O(n²)
特点：数据量增加时，时间呈平方级增长。如果人数翻倍，握手次数变为原来的 4 倍。
4. O (log n)：猜数字游戏
玩猜数字游戏，范围是 1-100。每次猜测后，对方会提示 "大了" 或 "小了"。最优策略是二分法：
java
public class GuessNumber {
public int guess(int answer) {
int low = 1;
int high = 100;
int guessCount = 0;
while (low <= high) {
guessCount++;
int mid = (low + high) / 2;
if (mid == answer) {
return guessCount; // 猜对了
} else if (mid < answer) {
low = mid + 1; // 猜小了，范围缩小到后半部分
} else {
high = mid - 1; // 猜大了，范围缩小到前半部分
}
}
return guessCount;
}
}
时间复杂度：O(log n)
特点：每次操作后，问题规模减半。即使数据量很大，所需时间也很少。例如：
- 猜 1-100 的数字，最多需要 7 次
- 猜 1-1000 的数字，最多需要 10 次
- 猜 1-10 亿的数字，最多需要 30 次
三、如何计算时间复杂度：抓住关键操作
计算时间复杂度时，只需关注最耗时的操作，忽略常数和低阶项。例如：
java
public void complexMethod(int n) {
// 操作1：O(1)
int a = 10;
// 操作2：O(n)
for (int i = 0; i < n; i++) {
System.out.println(i);
}
// 操作3：O(n²)
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
System.out.println(i + "," + j);
}
}
// 总时间复杂度：O(1) + O(n) + O(n²) → 保留最高阶项 → O(n²)
}
四、不同时间复杂度的性能对比
| 时间复杂度 | 数据量 n=10 | 数据量 n=100 | 数据量 n=1000 |
|---|---|---|---|
| O(1) | 1 | 1 | 1 |
| O(log n) | 3 | 7 | 10 |
| O(n) | 10 | 100 | 1000 |
| O(n²) | 100 | 10000 | 1000000 |
| O(2ⁿ) | 1024 | 1.27×10²⁹ | 1.07×10³⁰¹ |
可以看到，当数据量增大时，高时间复杂度的算法性能会急剧下降。
五、如何优化时间复杂度：从钓鱼故事中学到的
假设现在要在 1000 个文件中查找包含 "hello" 的文件：
原始方法（O (n)） ：
逐个打开文件检查，需要 1000 次操作。
优化方法（O (log n)） ：
如果文件按字母排序，可以用二分法：
-
先打开中间的文件
-
如果文件名在 "hello" 之前，忽略前半部分
-
如果文件名在 "hello" 之后，忽略后半部分
-
重复这个过程，直到找到或确定不存在
这样最多只需 10 次操作（2¹⁰ = 1024），效率提升了 100 倍！
六、总结：时间复杂度是选择算法的指南针
时间复杂度描述了算法的效率趋势，帮助我们在设计算法时做出明智选择：
-
优先选择低时间复杂度的算法（O(1) > O(log n) > O(n) > O(n²)）
-
避免指数级复杂度（O (2ⁿ)、O (n!)）的算法，数据量大时会崩溃
-
关注关键操作，忽略常数和低阶项
记住：好的算法就像高效的钓鱼方法，用更少的时间钓到更多的鱼。
