3

这可能是一件简单的事情,但我需要创建一个循环结构,使其循环 y^x 次以创建 x 和 y 的所有可能组合。例如,如果有 4 个 x,每个 x 有 2 个 y,我会想做类似的事情:

for(int a=0; a < y; a++){
    for(int b=0; b < y; b++){
        for(int c=0; c < y; c++){
            for(int d=0; d < y; d++){
                // create a new object with values of a, b, c, d
            }
        }
    }
}

基本上,创建 x 个嵌套 for 循环以创建总共 y^x 个对象(在本例中为 16 个)。假设 x 和 y 的值可以改变,那么最简单和最有效的方法是什么?我假设递归可能以某种方式涉及,但我不是 100% 确定如何去做。

4

2 回答 2

3

When you do not know the level of nesting at compile time, you need to use recursion: the function should have a single loop representing k-th nesting level, and continue calling itself recursively until the N-th level is reached:

-(void) nestAtLevel:(int)k withItems:(int[])items from:(int) from to:(int)to {
    if (k >= 0) {
        for (items[k] = from ; items[k] != to ; items[k]++) {
            [self nestAtLevel:k-1 withItems:items from:from to:to];
        }
    } else {
        // Use the indexes produced recursively: the current values are in items 1..N-1
        [self creatObjectsWithIndexes:items];
    }
}

The initial call should look like this:

int items[5];
[self nestAtLevel:4 withItems:items from:0 to:4];

I assume that there is also a function creatObjectsWithIndexes that takes an array of index items, and produces an object from them.

于 2013-04-07T19:36:33.593 回答
0

执行此操作的标准方法是使用递归。

你将有这样的功能:

void foo(int level, const int max_depth) {
    if (level == max_depth) {
         // code from final loop
         return;
    } else {
        for (...) {
            foo(level+1, max_depth);
        }
    }
 }

现在您可以在max_depth中传递任意数量的嵌套级别。

于 2013-04-07T19:33:30.420 回答