Question

很抱歉这个糟糕的标题，但我不知道如何在这里概括（或简化）我的循环案例。

我有一个迭代到整数序列的程序，例如dimension = 1到5。在每次迭代中，都会有一个主循环，在主循环内部会有一个嵌套循环。嵌套循环的数量将是[dimension]。例如，在维度= 1中，存在For循环。在维度= 2中，For循环内部存在For循环。等等。

有没有可能的方法来简化算法？目前我手动为[dimension]的每个值手动编写完全不同的代码。想象一下，如果维度= 1到100？我会死的

这是我的程序（用VB.NET编写）

for dimension = 2

Dim result(2) As Integer
For i = 0 To 1
    For j = 0 To 1
        result(0)=i
        result(1)=j
    Next
Next

维度= 3

 Dim result(3) As Integer
 For i = 0 To 1
     For j = 0 To 1
         For k = 0 To 1
             result(0)=i
             result(1)=j
             result(2)=k
         Next
     Next
 Next

维度= 4

Dim result(4) As Integer
For i = 0 To 1
    For j = 0 To 1
        For k = 0 To 1
            For l = 0 To 1
                result(0)=i
                result(1)=j
                result(2)=k
                result(3)=l
            Next
        Next
   Next
Next

等等..

有什么建议吗？谢谢！

Answer 1

有很多解决方案：

递归

Idk，如果vb.net支持方法，但如果确实如此，这可能是最简单的：

void nestedLoop(int lower , int upper , int remaining_loops , int[] values)
    if(remaining_loops == 0)
        //process values list
    else
        for int i in [lower , upper)
            values[remaining_loops] = i
            nestedLoop(lower , upper , remaining_loops - 1)

整数转换

理论上，数字可以用任何基数表示：

d_i * radix ^ i + d_i-1 * radix ^ (i - 1) ... + d_0 * radix ^ 0

将每个数字视为一个嵌套循环的值：

for int i in [0 , max)
    for int j in [0 , max)
        for int k in [0 , max)
            ...

可以用带有基数max的3位数字表示，其中d_0 = i，d_1 = j等。基本上每个数字如何映射到其中一个值可以是任意的并且只会影响输出的顺序。

void nestedLoops(int upper , int dimension)
    for int i in [0 , pow(upper , dimension))
        int[] values
        int digit_sub = 1

        int tmp = i
        for int j in [0 , dimension)
            values[j] = tmp % dimension
            tmp /= dimension

        //all values of the loops are now in values
        //process them here

还有其他一些选择，但这些是最常见的。

Answer 2

请注意，当你这样做时

Dim result(2) As Integer

您实际上声明了一个 3 元素数组see this question for why。这是VB.NET

中的一个细微差别

话虽如此，我假设您打算声明一个只包含2个元素的数组。如果是这种情况，那么你可以构建并调用像这样的递归函数

LoopOver(result) 

Sub LoopOver(ByRef array() As Integer, ByVal Optional level As Integer = 0)
    If array.Length = level Then
        Return
    Else
        array(level) = 1
        LoopOver(array, level + 1)
    End If
End Sub

这个递归函数将调用自身（即，它将循环）与数组大小一样多次。

推广越来越多的嵌套循环算法

2 个答案:

递归

整数转换