面试题：Rust 中如何在嵌套循环里有效使用 `break` 和 `continue` 控制多层循环

Question

假设你有一个多层嵌套的循环结构，例如一个二维数组遍历，外层是 `for` 循环，内层也是 `for` 循环。请描述如何合理使用 `break` 和 `continue` 语句，使得在外层循环满足某个条件时跳出整个嵌套循环，在内层循环满足另一个条件时跳过当前内层循环的剩余部分进入下一次内层循环，并给出相应代码示例。

Answer 1

1. 使用 break 跳出整个嵌套循环：
   • 当外层循环满足某个条件时，使用 break 可以跳出整个嵌套循环。假设我们要在二维数组中找到特定元素，一旦找到就跳出整个循环。

   matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
   target = 5
   for i in range(len(matrix)):
       for j in range(len(matrix[i])):
           if matrix[i][j] == target:
               print(f"找到目标元素 {target} 在位置 ({i}, {j})")
               break
       if matrix[i][j] == target:  # 这里利用内层循环结束后的状态，若找到则跳出外层循环
           break
   

2. 使用 continue 跳过当前内层循环剩余部分：
   • 当内层循环满足另一个条件时，使用 continue 跳过当前内层循环的剩余部分，进入下一次内层循环。例如，在遍历二维数组时，遇到负数就跳过当前内层循环的后续处理。

   matrix = [[1, -2, 3], [4, 5, -6], [7, 8, 9]]
   for i in range(len(matrix)):
       for j in range(len(matrix[i])):
           if matrix[i][j] < 0:
               continue
           print(f"处理元素 {matrix[i][j]}")
   

在C++ 中，代码示例如下：

1. 使用 break 跳出整个嵌套循环：

   #include <iostream>
   #include <vector>
   int main() {
       std::vector<std::vector<int>> matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
       int target = 5;
       for (size_t i = 0; i < matrix.size(); ++i) {
           for (size_t j = 0; j < matrix[i].size(); ++j) {
               if (matrix[i][j] == target) {
                   std::cout << "找到目标元素 " << target << " 在位置 (" << i << ", " << j << ")" << std::endl;
                   break;
               }
           }
           if (matrix[i][matrix[i].size() - 1] == target) {  // 这里利用内层循环结束后的状态，若找到则跳出外层循环
               break;
           }
       }
       return 0;
   }
   

2. 使用 continue 跳过当前内层循环剩余部分：

   #include <iostream>
   #include <vector>
   int main() {
       std::vector<std::vector<int>> matrix = {{1, -2, 3}, {4, 5, -6}, {7, 8, 9}};
       for (size_t i = 0; i < matrix.size(); ++i) {
           for (size_t j = 0; j < matrix[i].size(); ++j) {
               if (matrix[i][j] < 0) {
                   continue;
               }
               std::cout << "处理元素 " << matrix[i][j] << std::endl;
           }
       }
       return 0;
   }
   

在Java中，代码示例如下：

1. 使用 break 跳出整个嵌套循环：

   public class Main {
       public static void main(String[] args) {
           int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
           int target = 5;
           outerloop:
           for (int i = 0; i < matrix.length; i++) {
               for (int j = 0; j < matrix[i].length; j++) {
                   if (matrix[i][j] == target) {
                       System.out.println("找到目标元素 " + target + " 在位置 (" + i + ", " + j + ")");
                       break outerloop;
                   }
               }
           }
       }
   }
   

2. 使用 continue 跳过当前内层循环剩余部分：

   public class Main {
       public static void main(String[] args) {
           int[][] matrix = {{1, -2, 3}, {4, 5, -6}, {7, 8, 9}};
           for (int i = 0; i < matrix.length; i++) {
               for (int j = 0; j < matrix[i].length; j++) {
                   if (matrix[i][j] < 0) {
                       continue;
                   }
                   System.out.println("处理元素 " + matrix[i][j]);
               }
           }
       }
   }