c# - 有没有一种“聪明”的方法来摆脱嵌套循环？

Question

Closed. This question is opinion-based。它当前不接受答案。
                            
                        
                    
                
                            
                                
                
                        
                            
                        
                    
                        
                            想改善这个问题吗？更新问题，以便 editing this post用事实和引用来回答。
                        
                        4年前关闭。
                                                                                            
                
        
（目前，我主要使用C＃。欢迎使用其他语言编写的想法，但请尽可能将它们翻译为C＃，并且要明确。）

我一次又一次遇到的是一个嵌套循环，它在某个2D数组中搜索以找到一个元素（通常是某个对象），然后必须对其进行操作。因此，当然，一旦找到该对象，就应该同时退出两个循环，这样就不必不必要地继续搜索已找到的对象（尤其是在可以遍历指数级巨大数组的嵌套循环中）。

目前，以下代码是我首选的实现方式：

Obj O = null;
bool KeepLooping = true;

for (int j = 0; j < height && KeepLooping; j++)
{
    for (int i = 0; i < width; i++)
    {
        if (ObjArray[i, j] != null && ObjArray[i, j].property == search_value)
        {
            O = ObjArray[i, j]; // you found it, now remember it
            KeepLooping = false; // clear the flag so the outer loop will break too
            break;
        }
    }
}

感谢Erik Funkenbusch，如果执行此操作，它将变得更加优雅：

Obj O = null;
for (int j = 0; j < height && O == null; j++) // much, much better idea to check O for null in the outer loop
{
    for (int i = 0; i < width; i++)
    {
        if (ObjArray[i, j] != null && ObjArray[i, j].property == search_value)
        {
            O = ObjArray[i, j]; // you found it, now remember it
            break;
        }
    }
}

不再需要那讨厌的额外布尔值！

尽管如此，仍在寻找替代或更好的解决方案。多年来，我尝试了许多其他方法，但是由于一个或另一个原因，发现它们并不是那么好：


将 j（外循环迭代器）设置为大于 height的值，这将触发它自动中断。不理想，因为有时您想记住找到它的 i和 j值。
在2D阵列上使用 foreach。这并不理想，因为 foreach不允许您操作集合（删除或添加到集合，这通常是我无论如何都要搜索对象的原因）。
只需将2个循环放在一个函数中，该函数除了查找并返回 O外什么也不做。 return有效地打破了两个循环。很多时候这是可以的，但并非总是如此。我这样做是为了进行非常通用的搜索，但是我想将遍历遍历的地方也有很多“组搜索”。在那些情况下，我发现2个或更多对象（有时在同一2D数组中），记住它们，然后才脱离两个循环。
使用 goto？ （哇，这可能是goto的唯一合法用法吗？它比 KeepLooping标志更具可读性，特别是在我们有3个或更多循环的情况下。）这并不理想，因为同事们会大喊血腥谋杀案。在C＃中， goto之后是否将进行正确的垃圾清理？
引发自定义异常？ idk，我从未尝试过，但它的可读性比我目前首选的方式低。
找到正确的对象后，请在内循环内进行所有对象操作，然后 return;可能会很快变得混乱。有时，对象操作涉及其自身的循环。


还有第七种非常聪明的方法，这要感谢User_PWY：

int size = width*height; // save this so you dont have to keep remultiplying it every iteration
for (int i = 0; i < size; i++)
{
   int x = i % width; // ingenious method here
   int y = i / width; // ingenious method here

   O = ObjArray[x, y];

   if (O != null)
       break; // woohoo!
}

这有效地将2D数组压缩为一个 for循环以进行迭代。但是，一些批评指出，与仅i ++或j ++相比，mod和除法运算符的运行速度相当慢，因此它的运行速度可能会更慢（请记住，我们正在处理的是谁知道什么大小的2D数组）。就像我评论的那样，应该有一种方法可以在一个操作中进行除法和余数运算，因为我非常确定x86汇编代码具有DIV操作码，这些商数和余数存储在单独的寄存器中，全部存储在一条DIV指令中。但是如何在ID＃的C＃中执行/使用它。

如果C＃允许您命名循环（例如 L1和 L2），然后再执行类似 L1.break()的操作，那就太好了；无论您处于哪个循环中。 ......用这种语言无法做到。 （是否有使用宏执行此操作的秘密方法？）是否会有实现此功能的C＃6.0？

编辑：我认为，我会根据其优雅程度和速度来判断解决方案。请记住，我们正在处理嵌套循环，嵌套循环可能成倍增大。额外的操作或比较可能会有所作为。

好吧，好吧，告诉我您的首选方式，特别是如果此处未列出。

最佳答案

for (int i = 0; i < width*height; i++)
{
   int x=i%width
      ,y=i/width;
   //dostuff
}

我喜欢这种访问二维数组的方式。

评论1）
有很多评论担心mod（％）运算符可能会很昂贵，但这是我们正在讨论的整数运算，我认为它与其他解决方案没有什么区别。

评论2）
关于宏。我找不到代码，但设法简短地产生了代码。

#define FOR2DARRAY(WIDTH,HEIGHT) 
    \for (int i = 0, x = 0,y = 0; i < (WIDTH)*(HEIGHT); i++, x=i%(WIDTH),y=i/(HEIGHT))

关于c# - 有没有一种“聪明”的方法来摆脱嵌套循环？ ，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/30293637/

上一篇：c# - 通用列表在 C# 中添加空值

下一篇：c# - 如何将所有异常保存在数据库中，而无需在.Net 中的项目中到处调用函数？

相关文章：

python - 使用 Python 的 SQL 中的嵌套循环和 SELECT 语句

javascript - 对反转数组感到困惑

javascript - 7 行，包含数组中的值

C#在重定向的HttpWebRequest中发送cookie

c# - WPF 中的低分配绘图

c# - Windows 8 效果

linux - 需要修复小循环错误

c# - mysql 和 c# 日期时间的转换和比较

c# - 为什么无参数结构构造函数必须在 C# 6 中公开？

javascript - 在 *ngFor 循环中仅检查一个复选框(单选按钮行为)

Answer 1

for (int i = 0; i < width*height; i++)
{
   int x=i%width
      ,y=i/width;
   //dostuff
}

我喜欢这种访问二维数组的方式。

评论1）
有很多评论担心mod（％）运算符可能会很昂贵，但这是我们正在讨论的整数运算，我认为它与其他解决方案没有什么区别。

评论2）
关于宏。我找不到代码，但设法简短地产生了代码。

#define FOR2DARRAY(WIDTH,HEIGHT) 
    \for (int i = 0, x = 0,y = 0; i < (WIDTH)*(HEIGHT); i++, x=i%(WIDTH),y=i/(HEIGHT))