Lesson 0006 · 嵌套循环

① 程序设计基础 — 第 5 课

1. 嵌套循环是什么

一句话：外层走一步，内层跑一圈。

for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 2; j++) {
        cout << "(" << i << "," << j << ") ";
    }
    cout << endl;
}
// 输出：
// (0,0) (0,1)
// (1,0) (1,1)
// (2,0) (2,1)

执行顺序：i=0 → j=0,j=1 → 换行 → i=1 → j=0,j=1 → 换行 → i=2 → j=0,j=1

2. 经典用法

打印乘法表

for (int i = 1; i <= 9; i++) {             // 行
    for (int j = 1; j <= i; j++) {         // 列（每行列数递增）
        cout << j << "x" << i << "=" << i*j << "\t";
    }
    cout << endl;
}
// 输出经典的九九乘法表

打印图形

// 直角三角形
for (int i = 1; i <= 5; i++) {
    for (int j = 1; j <= i; j++) {
        cout << "*";
    }
    cout << endl;
}
/*
*
**
***
****
*****
*/

3. 嵌套循环 + 一维数组 = 去重

这就是你上节课卡住的那道题。核心思路：

vector<int> v = {3, 1, 4, 1, 5, 4};
vector<int> result;

for (int i = 0; i < v.size(); i++) {           // 外层：看每个数
    bool already = false;
    for (int j = 0; j < result.size(); j++) { // 内层：查 result 里有没有
        if (v[i] == result[j]) {
            already = true;
            break;           // 找到了，不用继续查
        }
    }
    if (!already) result.push_back(v[i]);     // 没找到，加进去
}
// result = {3, 1, 4, 5}

4. 嵌套循环 + vector = 排序

冒泡排序（经典中的经典）

vector<int> v = {5, 3, 8, 1, 2};
int n = v.size();

for (int i = 0; i < n - 1; i++) {             // 外层：第几轮
    for (int j = 0; j < n - 1 - i; j++) {     // 内层：两两比较
        if (v[j] > v[j + 1]) {                // 前面比后面大就交换
            int temp = v[j];
            v[j] = v[j + 1];
            v[j + 1] = temp;
        }
    }
}
// v = {1, 2, 3, 5, 8}

每轮把最大的"冒"到最后面。外层控制轮次，内层做比较交换。

5. 性能意识

6. 坑点清单

• 内外层变量别重名：外层用 i、内层用 j，内层再定义一次 i 会让两层互相干扰。
• 乘法表内层是 j <= i：每行列数递增；改成 j <= 9 就变成一个方阵，不是乘法表了。
• already 要写在外层循环里面：每个数都要重新判断一次，写在外面会一直是上一轮的结果。
• 冒泡内层是 j < n - 1 - i：写成 j < n 时 v[j + 1] 会越界。
• break 只跳出内层那一层：跳出后外层照常继续，别以为整个循环都停了。
• 次数是相乘不是相加：外层 3 次、内层 4 次，循环体执行 12 次。

7. 小测

8. 动手练习

卡住时的自查顺序

1. 先把外层写成「只打第 i 行」，确认行数和换行对不对，内层再做打印。
2. 内层的上界是不是依赖外层？三角形用 j <= i，从 1 开始更省事。
3. 每行打完后有没有 cout << endl;？忘了就全挤在一行。
4. 去重题：already 是不是写在外层循环体里面、每轮重置成 false？

本课小结

• 嵌套循环 = 外层一步，内层一圈，总次数 = 外层 × 内层。
• 打印图形：外层管行，内层管这一行打几个，行末记得换行。
• 去重：外层取数，内层查出现过的记录。
• 冒泡排序：每轮把最大元素"冒"到末尾，比较时和相邻元素交换。
• break 在嵌套循环里只跳出所在的那一层。