第五章——循环结构 第三节——循环的嵌套

一、什么是循环嵌套？

定义：

  在一个循环体内部再包含另一个完整的循环结构，称为循环嵌套。

特点

• 外层循环控制整体循环次数，内层循环负责具体操作。
• 执行流程：外层循环执行一次，内层循环需完整执行所有迭代，再回到外层循环继续下一次迭代。
• 组合形式：for、while、do-while可任意组合嵌套，例如：

  for(...) {          // 外层循环
      while(...) {    // 内层循环
          // 循环体
      }
  }

---

二、执行流程图解

以双重循环为例：

外层循环初始化 → 条件判断 → 条件为真  
    ↓  
执行外层循环体（含内层循环）  
    ↓  
内层循环初始化 → 条件判断 → 条件为真 → 执行内层循环体 → 更新内层变量 → 返回内层条件判断  
    ↓  
内层循环结束 → 更新外层变量 → 返回外层条件判断  

关键点：

• 内层循环必须在外层循环的一次迭代中完全执行完毕。
• 若内层循环未终止，外层循环无法进入下一次迭代。
• 外层循环在逻辑上必须是完整的。

---

三、经典案例解析

案例1：打印星号金字塔

#include <stdio.h>
int main() {
    int i, j, k;
    for(i = 0; i < 4; i++) {              // 控制行数
        for(j = 0; j < 3 - i; j++) 
            printf(" ");                  // 打印空格
        for(k = 0; k < 2*i + 1; k++) 
            printf("*");                  // 打印星号
        printf("\n");
    }
}

输出：

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

分析：

• 外层循环控制行数（4行）。
• 内层循环分两部分：
  1. 打印空格（数量随行数递减）。
  2. 打印星号（数量随行数递增）。

---

案例2：判断素数

#include <stdio.h>
int main() {
    int n, i;
    printf("请输入一个整数n：");
    scanf("%d", &n);
    for(i = 2; i < n; i++) {              // 尝试除以2~n-1
        if(n % i == 0) break;             // 若能整除，不是素数
    }
    if(i == n) 
        printf("%d是素数。\n", n);
    else 
        printf("%d不是素数。\n", n);
}

分析：

• 外层循环遍历除数（2到n-1）。
• 内层逻辑（if判断）：若找到因数，立即跳出循环，无需继续检查。

---

四、常见错误与避坑指南

错误类型	错误代码	修复方法
死循环	for(;;) { ... }	添加 break 或更新条件变量
循环变量作用域	for(int i=0; i<10; i++)	避免在循环外使用循环变量
缩进逻辑混乱	多层循环缩进不一致	使用统一缩进规范（如每层加4空格）
break误用	在内层循环直接break外层	使用标志位控制外层循环终止

典型陷阱：

for(int i = 0; i < 3; i++) {
    for(int j = 0; j < 3; j++) {
        if(i == 1 && j == 1) break;  // 仅跳出内层循环！
        printf("%d,%d\n", i, j);
    }
}

输出：

0,0  
0,1  
0,2  
1,0  
1,2  
2,0  
2,1  
2,2  

说明：break只能跳出当前所在的内层循环，外层循环继续执行。

---

五、真题实战：理解嵌套循环的执行

真题1：2007年4月计算机二级题

题目：以下程序输出什么？

main() {
    int i, j;
    for(i = 1; i < 4; i++) {
        for(j = i; j < 4; j++)
            printf("%d*%d=%d ", i, j, i*j);
        printf("\n");
    }
}

选项：
A.

1*1=1 1*2=2 1*3=3  
2*2=4 2*3=6  
3*3=9  
```  
B.  

11=1 12=2 13=3
21=2 22=4 23=6
31=3 32=6 3*3=9

**答案**：A  
**解析**：  
- 外层循环`i=1`时，内层`j=1→3`，输出`1*1=1`、`1*2=2`、`1*3=3`。  
- 外层`i=2`时，内层`j=2→3`，输出`2*2=4`、`2*3=6`。  
- 外层`i=3`时，内层`j=3`，输出`3*3=9`。

---

# 六、高级技巧与调试方法  

## 技巧1：使用标志位控制多层循环  
```c
int found = 0;
for(int i = 0; i < 10; i++) 
{
    for(int j = 0; j < 10; j++) 
    {
        if(condition) 
        {
            found = 1;
            break;  // 跳出内层循环
        }
    }
    if(found) break;  // 根据标志位跳出外层循环
}

解读

  这段代码有点小小的绕，逐步来解释一下。

int found = 0;  // 初始化标志位（0表示未找到目标）

1. 初始化阶段：创建found变量作为状态指示器，初始值为0表示尚未满足退出条件

for(int i = 0; i < 10; i++) {  // 外层循环控制器

2. 外层循环启动：i从0开始，循环10次（0-9），每次循环包含完整执行内层循环

for(int j = 0; j < 10; j++) {  // 内层循环控制器

3. 内层循环启动：j从0开始，每次外层循环执行时都会完整运行内层循环（最多10次）

if(condition) {  // 条件判断（实际应为具体条件表达式）

4. 条件检测：当遇到满足条件的case时（例如找到特定值），进入条件块

found = 1;  // 设置状态标志（1表示已找到目标）

5. 状态更新：将标志位置为1，通知外层循环需要提前终止

break;  // 终止内层循环（仅跳出当前j循环）

6. 跳出内层：立即结束当前内层循环，继续执行外层循环的后续代码

}
if(found) break;  // 检查到状态变化时跳出外层循环

7. 外层退出检查：当发现found变为1时，终止外层循环，完全退出双重循环结构

执行流程示意图：

i=0 → j=0→1→2...直到条件满足→found=1→break→外层检查found→break→程序继续
     ↖条件不满足时继续        ↗
i=1 → j=0→1→2...直到条件满足...
...

典型应用场景：

• 在二维数组中查找特定元素（如数字矩阵中找某个值）
• 嵌套数据结构的遍历（如坐标网格的扫描）
• 需要提前终止的双重循环场景（如密码破解尝试）

设计特点分析：
✅ 优点：

• 符合C语言结构化编程规范
• 明确的状态控制（标志位可见性好）
• 可扩展性强（可添加其他退出条件）

⚠️ 注意事项：

• 需要保持标志位作用域正确（不能在函数间传递）
• 条件判断必须具体有效（原代码中需替换为实际条件）
• 多线程环境下需考虑原子操作（非本例场景）

性能特征：

• 最坏情况执行100次循环体（10×10）
• 最早可在第一次迭代就终止（当condition在i=0,j=0时成立）
• 空间复杂度O(1)（仅使用固定数量的变量）

---

技巧2：打印调试信息追踪流程

for(int i = 1; i <= 2; i++) {
    printf("外层循环第%d次\n", i);
    for(int j = 1; j <= 2; j++) {
        printf("  内层循环第%d次\n", j);
    }
}

输出：

外层循环第1次  
  内层循环第1次  
  内层循环第2次  
外层循环第2次  
  内层循环第1次  
  内层循环第2次  

---

七、总结：嵌套循环的哲学

• 适用场景：
  • 多维度数据处理（如矩阵运算）。
  • 分层任务（如打印图形、批量验证素数）。
• 核心原则：
  • 先设计外层逻辑，再细化内层操作。
  • 避免无限嵌套，超过3层应考虑拆分函数。
• 记忆口诀：
  「外层控次数，内层做操作；break只跳一层，标志位助跳多层」。

就像人生选择——单层循环是直线思维，嵌套循环则是立体规划！