【C语言指南】循环嵌套的复杂度分析与优化

循环嵌套的复杂度分析

1. 算法复杂度的概念
   算法复杂度是衡量算法性能的重要指标，它主要包括时间复杂度和空间复杂度。时间复杂度反映了算法执行所需的时间与输入规模之间的关系，而空间复杂度则衡量了算法在运行过程中所需的额外存储空间与输入规模的关系。在实际编程中，我们通常希望算法具有较低的时间复杂度和空间复杂度，这样可以提高程序的运行效率和资源利用率。
2. 推导大 O 阶的方法
   在计算算法的时间复杂度时，我们通常使用大 O 的渐进表示法。推导大 O 阶的方法主要有以下三个步骤：

• 用常数 1 取代运行时间中的所有加法常数：例如，如果算法的执行次数为 T (n) = 2n + 3，我们将其中的加法常数 3 用 1 取代，得到 T (n) = 2n + 1。这是因为当输入规模 n 足够大时，常数项对算法执行时间的影响可以忽略不计。比如在一个循环中，无论循环体执行前有多少固定次数的初始化操作，当循环次数极大时，这些初始化操作的时间占比就会极小。
• 保留最高阶项：在修改后的运行次数函数中，只保留最高阶项。对于 T (n) = 2n + 1，最高阶项是 2n，所以我们只保留 2n，得到 T (n) = 2n。因为随着输入规模 n 的增大，最高阶项的增长速度远远快于其他低阶项，对算法执行时间的影响最大。以一个包含线性项和常数项的函数为例，当 n 不断增大，常数项的值几乎可以忽略不计，而线性项的值会不断增大，主导整个函数的增长。
• 去除最高阶项相乘的常数：如果最高阶项存在且不是 1，则去除与这个项目相乘的常数。对于 T (n) = 2n，去除常数 2，最终得到大 O 阶表示为 O (n)。这是因为在大 O 表示法中，我们关注的是算法执行时间随输入规模增长的趋势，而不是具体的系数。比如 O (2n) 和 O (n) 在增长趋势上是一致的，当 n 增大时，它们的增长速度的相对关系不变，所以我们统一用 O (n) 来表示。

1. 循环嵌套的时间复杂度计算
   对于循环嵌套的代码，其时间复杂度的计算需要考虑每层循环的执行次数。

• 以常见的双层 for 循环嵌套为例：

在这个例子中，外层循环执行 n 次，对于外层循环的每一次迭代，内层循环都会执行 n 次。因此，循环体的总执行次数为 n * n = n²，所以这段代码的时间复杂度为 O (n²)。这意味着当输入规模 n 增大时，算法的执行时间会以 n² 的速度增长。比如当 n 从 100 增加到 200 时，执行时间会从 100² 增加到 200²，增长速度非常快。

• 再看一个更复杂的三层循环嵌套的例子：

对于这个三层循环，外层循环执行 n 次。中层循环的执行次数取决于外层循环变量 i，当 i = 0 时，中层循环执行 0 次；当 i = 1 时，中层循环执行 1 次；以此类推，当 i = n - 1 时，中层循环执行 n - 1 次。所以中层循环的总执行次数为 1 + 2 + 3 +... + (n - 1)，根据等差数列求和公式，其和为 (n - 1) * n / 2。对于中层循环的每一次执行，内层循环的执行次数又取决于中层循环变量 j，同样按照上述方式分析，内层循环的总执行次数也是一个与 n 相关的累加和。最终，通过数学推导可以得出这段代码的时间复杂度为 O (n³)。这表明随着 n 的增大，算法执行时间的增长速度比 O (n²) 更快，计算量呈指数级增长。

1. 空间复杂度分析
   循环嵌套的空间复杂度主要取决于在运行时显式申请的额外空间。

• 在大多数简单的循环嵌套示例中，如果没有在循环内部显式地申请大量额外的空间（如数组、动态内存分配等），空间复杂度通常为 O (1)。例如前面的打印整数矩阵和九九乘法表的例子，它们只使用了几个简单的变量（如循环控制变量 i 和 j），这些变量所占用的空间是固定的，不随输入规模 n 的变化而变化，所以空间复杂度为 O (1)。
• 然而，如果在循环嵌套中动态分配了与输入规模相关的空间，那么空间复杂度就会发生变化。例如：

在这个例子中，我们动态分配了一个 n x n 的二维数组。总共分配的空间大小为 n * n * sizeof (int)，与输入规模 n 的平方成正比。因此，这个算法的空间复杂度为 O (n²)。这说明在分析循环嵌套的空间复杂度时，要特别注意是否有动态内存分配等操作，以及这些操作所占用的空间与输入规模的关系。如果动态分配的空间与输入规模成线性关系，那么空间复杂度就是 O

for (int i = 0; i < n; i++) {  // 外层循环，执行n次
    for (int j = 0; j < n; j++) {  // 内层循环，对于外层循环的每一次，内层循环都执行n次
        // 循环体，执行次数为n * n
    }
}

for (int i = 0; i < n; i++) {  // 外层循环，执行n次
    for (int j = 0; j < i; j++) {  // 中层循环，执行次数与外层循环变量i有关，最多执行n - 1次
        for (int k = 0; k < j; k++) {  // 内层循环，执行次数与中层循环变量j有关
            // 循环体
        }
    }
}

#include 
#include 

int main() {
    int n = 5;
    int **matrix = (int **)malloc(n * sizeof(int *));  // 动态分配一个包含n个指针的数组
    for (int i = 0; i < n; i++) {
        matrix[i] = (int *)malloc(n * sizeof(int));  // 为每个指针分配一个包含n个整数的数组
        for (int j = 0; j < n; j++) {
            matrix[i][j] = i * j;  // 给矩阵元素赋值
        }
    }
    // 打印矩阵（省略）
    // 释放内存
    for (int i = 0; i < n; i++) {
        free(matrix[i]);
    }
    free(matrix);
    return 0;
}