C# 嵌套循环（一文讲透）

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

• 新项目:《从零手撸：仿小红书（微服务架构）》 正在持续爆肝中，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;
• 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 82w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 2900+ 小伙伴加入学习 ，欢迎点击围观

在编程领域中，循环结构是解决问题的核心工具之一。而 C# 嵌套循环 作为循环的进阶用法，能够帮助开发者高效处理二维数据、复杂逻辑以及需要分层控制的场景。无论是打印图形、遍历多维数组，还是实现算法中的双重条件判断，嵌套循环都能提供简洁且直观的解决方案。本文将从基础概念出发，结合具体案例，逐步解析 C# 嵌套循环 的实现原理、应用场景及优化技巧，并通过形象的比喻帮助读者建立直观理解。

基础概念：什么是嵌套循环？

嵌套循环（Nested Loops）指在循环内部再定义另一个循环的结构。在 C# 中，常见的循环结构包括 for、while 和 do-while，它们均可进行嵌套。外层循环（Outer Loop）控制整体流程，内层循环（Inner Loop）则负责完成更具体的子任务。

形象比喻：想象一个“楼层与房间”的场景

假设你站在一栋大楼前，外层循环相当于“逐层遍历楼层”，而内层循环则代表“在每一层中逐个检查房间”。例如：

• 外层循环：从第 1 层到第 10 层
• 内层循环：在当前楼层的每个房间（如房间 1 到房间 10）中执行操作

这种分层结构让代码能够处理二维数据（如表格、棋盘）或需要逐级细化的逻辑问题。

核心语法：如何实现 C# 嵌套循环？

在 C# 中，嵌套循环的语法非常直观。以下通过 for 循环的嵌套为例说明：

for (int i = 0; i < 3; i++) { // 外层循环  
    for (int j = 0; j < 3; j++) { // 内层循环  
        Console.WriteLine($"当前坐标：({i}, {j})");  
    }  
}

关键点解析

1. 变量作用域：
   内层循环的变量（如 j）仅在内层循环的作用域内有效，外层循环的变量（如 i）则可被内层访问。
2. 执行顺序：
   外层循环每完成一次迭代，内层循环会完整执行一次。例如，上述代码会输出 3×3=9 次结果。
3. 循环条件独立：
   外层和内层循环的条件彼此独立，但内层循环的执行次数会直接影响整体效率。

案例分析：常见应用场景与代码示例

案例 1：打印数字金字塔

需求：输出以下图形：

1  
1 2  
1 2 3  
1 2 3 4  

实现思路：

• 外层循环控制行数（从 1 到 4 行）
• 内层循环控制每行的列数（从 1 到当前行号）

for (int row = 1; row <= 4; row++) {  
    for (int col = 1; col <= row; col++) {  
        Console.Write(col + " ");  
    }  
    Console.WriteLine(); // 换行  
}

案例 2：矩阵乘法运算

需求：计算两个二维数组的乘积。
数学公式：
若矩阵 A 是 m×n，矩阵 B 是 n×p，则结果矩阵 C 是 m×p，其中每个元素 C[i][j] = A[i][0]*B[0][j] + A[i][1]*B[1][j] + ... + A[i][n-1]*B[n-1][j]。

C# 实现：

int[,] matrixA = { {1, 2}, {3, 4} }; // 2×2 矩阵  
int[,] matrixB = { {5, 6}, {7, 8} }; // 2×2 矩阵  
int[,] result = new int[2, 2];  

for (int i = 0; i < 2; i++) { // 遍历 matrixA 的行  
    for (int j = 0; j < 2; j++) { // 遍历 matrixB 的列  
        for (int k = 0; k < 2; k++) { // 内层循环计算每个元素的和  
            result[i, j] += matrixA[i, k] * matrixB[k, j];  
        }  
    }  
}

注意：此处使用了三层循环，但实际应用中需根据矩阵维度动态调整。

优化技巧：提升嵌套循环的效率

问题：内层循环的性能瓶颈

假设有一个 1000×1000 的二维数组，若内层循环执行复杂计算，则总时间复杂度为 O(n²)，可能引发性能问题。

优化方法

1. 提前终止循环：
   若发现满足条件的结果，可直接跳出循环。

   for (int i = 0; i < 1000; i++) {  
       for (int j = 0; j < 1000; j++) {  
           if (array[i, j] == target) {  
               Console.WriteLine("找到目标！");  
               goto ExitLoop; // 或使用 break 和标签  
           }  
       }  
   }  
   ExitLoop:  
   

2. 减少内层计算量：
   将可复用的计算结果提前存储在外层循环中。

   for (int i = 0; i < n; i++) {  
       int outerValue = CalculateExpensiveFunction(i); // 外层计算  
       for (int j = 0; j < m; j++) {  
           // 使用 outerValue 而非重复计算  
           ...  
       }  
   }  
   

3. 利用并行化（Parallel）：
   对于独立的内层循环任务，可使用 Parallel.For 加速。

   Parallel.For(0, 10, (i) => {  
       // 内层逻辑  
   });  
   

常见错误与调试技巧

错误 1：变量作用域混淆

int count = 0;  
for (int i = 0; i < 3; i++) {  
    for (int j = 0; j < 3; j++) {  
        count += i + j; // 正确  
        // 错误：j = i; // 可能导致循环条件混乱  
    }  
}  

注意：修改内层循环变量（如 j）可能打破循环逻辑，需谨慎操作。

错误 2：无限循环

for (int i = 0; i < 5; i++) {  
    for (int j = 0; j < 5; ) { // 缺少 j++ 导致死循环  
        Console.WriteLine("死循环中...");  
    }  
}  

调试技巧：使用断点逐步跟踪循环变量的值，或添加 Console.WriteLine 输出中间结果。

进阶应用：结合条件判断与多层嵌套

案例：素数矩阵筛法

需求：生成一个 10×10 矩阵，标记其中的素数（质数）。
实现逻辑：

1. 外层循环遍历矩阵的每个元素。
2. 内层循环判断当前数是否为素数。

bool[,] primeMatrix = new bool[10, 10];  

for (int num = 2; num <= 100; num++) { // 遍历 1-100  
    int row = (num - 1) / 10;          // 计算行列位置  
    int col = (num - 1) % 10;  
    bool isPrime = true;  
    for (int divisor = 2; divisor * divisor <= num; divisor++) { // 素数判断  
        if (num % divisor == 0) {  
            isPrime = false;  
            break;  
        }  
    }  
    primeMatrix[row, col] = isPrime;  
}  

总结与展望

通过本文的学习，读者应能掌握 C# 嵌套循环 的核心概念、语法结构及实际应用。无论是打印图形、矩阵运算，还是复杂算法的实现，嵌套循环都能提供高效、灵活的解决方案。

关键知识点回顾

后续学习建议

1. 探索其他循环结构（如 while 和 do-while）的嵌套用法。
2. 结合 LINQ（Language Integrated Query）优化数据遍历逻辑。
3. 学习多线程与并行编程，进一步提升嵌套循环的执行效率。

掌握嵌套循环不仅是编程技能的提升，更是解决复杂问题的关键一步。通过持续实践与案例分析，开发者能够更自信地应对各种场景下的循环挑战。