本文深入探讨了当一个方法内部调用另一个方法时，如何准确评估其整体时间复杂度。通过一个具体的O(n^2)方法内部调用O(n)方法的案例，详细分析了这种嵌套调用如何导致整体复杂度从O(n^2)提升至O(n^3)。文章强调了在进行复杂度分析时，必须全面考虑所有被调用函数的开销，特别是当它们位于循环结构内部时。
在算法设计与分析中，时间复杂度是衡量算法效率的关键指标。它描述了算法执行时间与输入数据规模之间的关系，通常使用大O符号（Big O notation）表示。然而，当一个方法（或函数）内部调用了另一个方法时，其整体时间复杂度的计算往往会变得复杂，尤其是在循环结构中进行调用时。本文将通过一个具体的Java代码示例，深入分析这种嵌套函数调用的时间复杂度计算方法。
时间复杂度的基本概念回顾
时间复杂度通常表示为 O(f(n))，其中 n 是输入数据的大小，f(n) 表示随着 n 增长，算法执行所需操作次数的增长趋势。常见的时间复杂度包括 O(1)（常数时间）、O(log n)（对数时间）、O(n)（线性时间）、O(n log n)（线性对数时间）、O(n^2)（平方时间）和 O(n^3)（立方时间）等。在计算时间复杂度时，我们关注的是最坏情况下的性能表现，并忽略常数因子和低阶项。
嵌套函数调用中的复杂度计算原则
当一个方法 A 调用另一个方法 B 时，方法 A 的总时间复杂度是其自身操作的复杂度与方法 B 被调用所产生的总复杂度的叠加。
- 单次调用: 如果方法 A 只调用一次方法 B，那么 TC(A) = TC(A_自身操作) + TC(B)。
- 多次调用（固定次数）: 如果方法 A 调用方法 B 固定 K 次，那么 TC(A) = TC(A_自身操作) + K * TC(B)。
- 循环内部调用: 这是最复杂也是最常见的情况。如果方法 A 在一个循环中调用方法 B，并且循环的迭代次数或每次调用 B 的开销与输入规模 n 相关，那么 TC(A) 需要将循环的迭代次数与每次 B 的调用开销相乘。
核心原则是：任何一行代码的执行开销，无论它属于哪个函数，都必须被计入最终的整体时间复杂度。
案例分析：O(n^2) 方法调用 O(n) 方法
让我们分析以下Java代码示例，其中 what 方法调用了 f 方法：
public class ComplexityAnalysis {
private static int f (int[]a, int low, int high) {
int res = 0;
// 循环从 low 到 high，执行 high - low + 1 次
for (int i=low; i<=high; i++) {
res += a[i];
}
return res;
}
public static int what (int []a) {
int temp = 0;
// 外层循环：i 从 0 到 a.length - 1
for (int i=0; i<a.length; i++) {
// 内层循环：j 从 i 到 a.length - 1
for (int j=i; j<a.length; j++) {
// 在内层循环中调用 f 方法
int c = f(a, i, j);
if (c%2 == 0) {
if (j-i+1 > temp)
temp = j-i+1;
}
}
}
return temp;
}
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 
