跳到主要内容

C++ 嵌套循环

在编程世界中，循环是最基本也是最强大的控制结构之一。当我们需要处理更复杂的重复任务时，一个循环可能不够用，这时就需要用到嵌套循环。嵌套循环是指在一个循环内部包含另一个循环的结构。

什么是嵌套循环？​

嵌套循环是指在一个循环体内再放置另一个循环的结构。外层循环每执行一次，内层循环将完整执行一遍。这种结构允许我们处理多维数据或者实现更复杂的重复逻辑。

嵌套循环的基本结构如下：

cpp
for (初始化外层循环变量; 外层循环条件; 外层循环迭代) {
    // 外层循环代码
    
    for (初始化内层循环变量; 内层循环条件; 内层循环迭代) {
        // 内层循环代码
    }
    
    // 更多外层循环代码
}

嵌套循环的工作原理​

让我们通过一个简单的例子来理解嵌套循环的工作原理：

cpp
#include <iostream>
using namespace std;

int main() {
    for (int i = 1; i <= 3; i++) {
        cout << "外层循环迭代: " << i << endl;
        
        for (int j = 1; j <= 2; j++) {
            cout << "  内层循环迭代: " << j << endl;
        }
    }
    
    return 0;
}

输出：

外层循环迭代: 1
  内层循环迭代: 1
  内层循环迭代: 2
外层循环迭代: 2
  内层循环迭代: 1
  内层循环迭代: 2
外层循环迭代: 3
  内层循环迭代: 1
  内层循环迭代: 2
提示

理解嵌套循环的关键是：外层循环执行一次，内层循环将完整执行其所有迭代。

嵌套循环的执行顺序​

为了更直观地理解嵌套循环的执行，我们可以看以下流程图：

嵌套循环的使用场景​

1. 打印图案​

嵌套循环最常见的应用之一是打印各种图案。例如，打印一个星号组成的矩形：

cpp
#include <iostream>
using namespace std;

int main() {
    int rows = 4;
    int columns = 5;
    
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < columns; j++) {
            cout << "* ";
        }
        cout << endl;
    }
    
    return 0;
}

输出：

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

2. 处理二维数组​

嵌套循环非常适合处理二维数组，外层循环遍历行，内层循环遍历列：

cpp
#include <iostream>
using namespace std;

int main() {
    // 定义一个3x3的二维数组
    int matrix[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    
    // 使用嵌套循环输出数组元素
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            cout << matrix[i][j] << " ";
        }
        cout << endl;
    }
    
    return 0;
}

输出：

1 2 3 
4 5 6 
7 8 9

3. 生成乘法表​

我们可以使用嵌套循环来生成乘法表：

cpp
#include <iostream>
#include <iomanip>  // 用于格式化输出
using namespace std;

int main() {
    int n = 9;  // 9x9乘法表
    
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= i; j++) {
            cout << j << "×" << i << "=" << setw(2) << i * j << " ";
        }
        cout << endl;
    }
    
    return 0;
}

输出：

1×1= 1 
1×2= 2 2×2= 4 
1×3= 3 2×3= 6 3×3= 9 
1×4= 4 2×4= 8 3×4=12 4×4=16 
1×5= 5 2×5=10 3×5=15 4×5=20 5×5=25 
1×6= 6 2×6=12 3×6=18 4×6=24 5×6=30 6×6=36 
1×7= 7 2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49 
1×8= 8 2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64 
1×9= 9 2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81

嵌套循环中不同循环类型的组合​

C++中的嵌套循环可以混合使用不同类型的循环，如for、while和do-while。

for循环嵌套while循环​

cpp
#include <iostream>
using namespace std;

int main() {
    for (int i = 1; i <= 3; i++) {
        int j = 1;
        while (j <= 3) {
            cout << i << "," << j << " ";
            j++;
        }
        cout << endl;
    }
    
    return 0;
}

输出：

1,1 1,2 1,3 
2,1 2,2 2,3 
3,1 3,2 3,3

while循环嵌套for循环​

cpp
#include <iostream>
using namespace std;

int main() {
    int i = 1;
    while (i <= 3) {
        for (int j = 1; j <= 3; j++) {
            cout << i << "," << j << " ";
        }
        cout << endl;
        i++;
    }
    
    return 0;
}

输出：

1,1 1,2 1,3 
2,1 2,2 2,3 
3,1 3,2 3,3

实际应用案例：找出所有质数对​

使用嵌套循环来找出一定范围内所有的质数对（两个相邻的质数，它们之差为2）：

cpp
#include <iostream>
#include <cmath>
using namespace std;

bool isPrime(int n) {
    if (n <= 1) return false;
    if (n <= 3) return true;
    if (n % 2 == 0 || n % 3 == 0) return false;
    
    for (int i = 5; i * i <= n; i += 6) {
        if (n % i == 0 || n % (i + 2) == 0) {
            return false;
        }
    }
    return true;
}

int main() {
    int limit = 50;
    
    cout << "50以内的质数对：" << endl;
    
    // 外层循环遍历可能的质数
    for (int i = 3; i <= limit - 2; i++) {
        // 内层检查是否形成质数对
        if (isPrime(i) && isPrime(i + 2)) {
            cout << "(" << i << ", " << i + 2 << ")" << endl;
        }
    }
    
    return 0;
}

输出：

50以内的质数对：
(3, 5)
(5, 7)
(11, 13)
(17, 19)
(29, 31)
(41, 43)

嵌套循环的性能考虑​

嵌套循环会显著增加程序的执行时间。假设外层循环执行n次，内层循环执行m次，那么总的执行次数就是n×m次。当处理大量数据时，需要特别注意嵌套循环的效率问题。

警告

如果有三层嵌套循环，每层执行100次，那么总的执行次数将达到100×100×100=1,000,000次！这可能导致程序运行缓慢。

嵌套循环的优化技巧​

  1. 尽早跳出循环：使用break语句在条件满足时提前结束循环。

  2. 避免不必要的计算：将不随循环变化的计算移到循环外部。

  3. 考虑循环顺序：对于多维数组，按照内存布局访问数据可以提高缓存命中率。

cpp
// 低效率的二维数组访问（不符合C++数组内存布局）
for (int j = 0; j < columns; j++) {
    for (int i = 0; i < rows; i++) {
        array[i][j] = 0;
    }
}

// 高效率的二维数组访问（符合C++数组内存布局）
for (int i = 0; i < rows; i++) {
    for (int j = 0; j < columns; j++) {
        array[i][j] = 0;
    }
}

总结​

嵌套循环是C++中处理复杂重复任务的强大工具，特别适用于二维数据处理和图案生成。理解嵌套循环的执行顺序和应用场景对于编写高效、清晰的代码至关重要。

关键要点：

  • 嵌套循环是一个循环内包含另一个循环的结构
  • 外层循环每执行一次，内层循环将完整执行一遍
  • 嵌套循环适用于处理多维数据、打印图案等场景
  • 可以混合使用不同类型的循环（for、while、do-while）
  • 嵌套层数越多，执行时间复杂度越高，需要注意性能问题

练习题​

  1. 编写一个程序，使用嵌套循环打印一个金字塔图案。
  2. 使用嵌套循环计算并打印一个5×5的二维数组的转置矩阵。
  3. 编写一个程序，找出100以内所有的完全数（完全数是指它的所有真因子之和等于它本身，如6=1+2+3）。
  4. 使用三层嵌套循环找出1000以内的所有毕达哥拉斯三元组（满足a²+b²=c²的三个正整数）。
备注

嵌套循环是编程中不可或缺的基本结构，掌握它将使你能够解决更复杂的问题。随着经验的积累，你将逐渐学会何时使用嵌套循环以及如何优化它们。