1. 什么是嵌套循环？

嵌套循环（Nested Loops）是指一个循环语句的循环体内包含另一个或多个完整的循环结构。它就像时钟的时针、分针和秒针：秒针转一圈（内层循环），分针走一格；分针转一圈（中层循环），时针走一格。

2. 基本语法结构

C语言中的三种循环（for, while, do-while）可以相互任意组合嵌套。最常用的是 for 循环嵌套。

2.1、 for 循环嵌套

这是最常见的形式，结构清晰，通常用于循环次数已知的场景。

for (初始化外层; 条件外层; 调整外层) {
    // 外层循环体
    for (初始化内层; 条件内层; 调整内层) {
        // 内层循环体
    }
    // 外层循环体其他代码
}

2.2、while 循环嵌套

while (条件外层) {
    // 外层循环体
    while (条件内层) {
        // 内层循环体
    }
    // 外层循环体其他代码
}

2.3、混合嵌套

不同类型的循环也可以相互嵌套。

for (初始化外层; 条件外层; 调整外层) {
    while (条件内层) {
        // 内层循环体
    }
}

3. 执行流程与特点

关键特点：对于外层循环的每一次迭代，内层循环都会完整地执行所有次迭代。
示例代码：

#include <stdio.h>

int main() {
    int i, j;
    
    // 外层循环控制行
    for (i = 1; i <= 3; i++) {
        printf("外层循环 i = %d\n", i);
        
        // 内层循环控制列
        for (j = 1; j <= 2; j++) {
            printf("  内层循环 j = %d\n", j);
        }
        
        printf("外层循环第 %d 次结束\n\n", i);
    }
    
    return 0;
}

输出结果：

外层循环 i = 1
  内层循环 j = 1
  内层循环 j = 2
外层循环第 1 次结束

外层循环 i = 2
  内层循环 j = 1
  内层循环 j = 2
外层循环第 2 次结束

外层循环 i = 3
  内层循环 j = 1
  内层循环 j = 2
外层循环第 3 次结束

执行顺序详解：
1、i = 1，进入外层循环第一次迭代
2、执行内层循环：j 从 1 到 2，完成两次迭代
3、继续执行外层循环体剩余代码
4、i++ → i = 2，开始外层循环第二次迭代
5、内层循环重新初始化，j 再次从 1 到 2
6、重复此过程直到外层循环结束

4、控制嵌套循环：break 和 continue

在嵌套循环中使用 break 和 continue 时需要特别注意：
1、break：跳出当前所在的那一层循环
2、、continue：跳过当前所在循环的本次迭代，继续下一次
示例：使用 break 跳出内层循环

for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 5; j++) {
        if (j == 2) {
            break; // 只跳出内层循环，外层循环继续
        }
        printf("i=%d, j=%d\n", i, j);
    }
}

5、经典应用示例

示例1：打印乘法口诀表

#include <stdio.h>

int main() {
    int i, j;
    
    for (i = 1; i <= 9; i++) {        // 控制行（被乘数）
        for (j = 1; j <= i; j++) {    // 控制列（乘数），j<=i 只打印下三角
            printf("%d×%d=%-2d  ", j, i, i * j); // %-2d 左对齐，占2位
        }
        printf("\n"); // 换行
    }
    
    return 0;
}

示例2：遍历二维数组

#include <stdio.h>

int main() {
    int matrix[3][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };
    
    for (int i = 0; i < 3; i++) {        // 遍历行
        for (int j = 0; j < 4; j++) {    // 遍历列
            printf("%d\t", matrix[i][j]);
        }
        printf("\n");
    }
    
    return 0;
}

示例3：打印图案（金字塔）

#include <stdio.h>

int main() {
    int rows = 5;
    
    for (int i = 1; i <= rows; i++) {
        // 打印空格
        for (int j = i; j < rows; j++) {
            printf(" ");
        }
        // 打印星号
        for (int k = 1; k <= (2 * i - 1); k++) {
            printf("*");
        }
        printf("\n");
    }
    
    return 0;
}

输出：

    *
   ***
  *****
 *******
*********

6. 跳出多层嵌套循环的几种方法

如果需要一次性跳出多层循环，有几种常见方法：
方法1：使用 goto（谨慎使用）

for (int i = 0; i < 10; i++) {
    for (int j = 0; j < 10; j++) {
        if (condition) {
            goto exit_loops; // 直接跳出所有循环
        }
    }
}
exit_loops:
// 后续代码

方法2：使用标志变量（推荐）

int break_all = 0; // 标志变量

for (int i = 0; i < 10 && !break_all; i++) {
    for (int j = 0; j < 10 && !break_all; j++) {
        if (condition) {
            break_all = 1;
            break; // 先跳出内层
        }
    }
    // 外层循环通过检查 break_all 来决定是否继续
}

方法3：将嵌套循环封装成函数

void process_loops() {
    for (int i = 0; i < 10; i++) {
        for (int j = 0; j < 10; j++) {
            if (condition) {
                return; // 直接返回，跳出所有循环
            }
        }
    }
}

7. 性能注意事项

1、循环顺序很重要：在遍历多维数组时，尽量让内层循环遍历连续的内存地址（如二维数组的列），可以利用CPU缓存提升性能。
2、避免不必要的嵌套：如果嵌套层数过深（如超过3层），考虑是否可以重构代码。
3、减少内层循环的计算量：将能在循环外计算的表达式提到循环外。