Question

我不知道这是否是一个愚蠢的问题，但我需要动态更改for循环的数量而不使用递归。

例如，如果n = 3，我需要3个嵌套的for循环。

for(int i=0; i<size; i++){
   for(int j=0; j<size-1; j++){
       for(int k=0; k<size-2; k++){
          //do something
       }
   }
}

如果n = 5：

for(int i=0; i<size; i++){
   for(int j=0; j<size-1; j++){
       for(int k=0; k<size-2; k++){
          for(int l=0; l<size-3; l++){
              for(int m=0; m<size-4; m++){
                  //do something
              }
          }
       }
   }
}

有没有办法在没有递归的情况下实现这一目标？另一个问题：在Java中使用Multiple Dispatch有什么用？我试图用一种方法编写代码，它应该在参数的不同情况下运行不同的事件。如果声明/三元运营商/案例。

注意：我只能有一个方法（部分问题），并且不能使用递归。遗憾。

Answer 1

考虑一下你完成这个循环的次数。它看起来像(size!) / (size - n)!：

int numLoops = 1;
for (int i = 0; i < n; i++) {
    numLoops*= (size - i);
}

for (int i = 0; i < numLoops; i++) {
    //do something
}

Answer 2

这取决于你究竟想要做什么。递归总是可以用迭代替换（有关使用Stack存储状态的示例，请参阅this post）。

但也许模数（％）运算符可以在这里工作？即，使用单个循环递增变量（i），然后使用模（i % 3等）计算其他变量。如果变量数量不同，您可以使用Map间接存储变量的值。

Answer 3

您必须创建循环计数器数组并手动递增。

快速而肮脏的例子：

public static void nestedFors(int n, int size) {
  assert n > size;
  assert size > 0;

  int[] i = new int[n];
  int l = n - 1;
  while(l >= 0) {
    if(l == n - 1) {
      System.out.println(Arrays.toString(i));
    }
    i[l]++;
    if(i[l] == size - l) {
      i[l] = 0;
      l--;
    } else if(l < n - 1) {
      l++;
    }
  }
}

将System.out.println(Arrays.toString(i))替换为您自己的代码。

您可以在此处查看：http://ideone.com/IKbDUV

Answer 4

我认为你需要一个回溯算法。但是你会用递归替换你的嵌套循环。

我不想在这里发布链接，因为似乎主持人不喜欢这样。

看看“八皇后拼图”（你可以谷歌吧），你会得到我的想法。

我知道这个想法很有效，因为我在很多场合都向自己提出了同样的问题，并且我已成功应用了几次。

这是一个小例子（我改变它，因为前一个有点复杂）。

public class Test001 {

public static void main(String[] args) {
    loop(0, 5, 10);
}

/**
 * max_level - the max count of nesting loops
 * size - the size of the collection
 * 
 * 0 - top most level
 * level 1 - nested into 0
 * level 2 - nested into 1
 * ... 
 * and so on.
 */
private static void loop(int level, int max_level, int size){
    if (level > max_level) return;

    for (int i=0; i<size-level; i++){
        System.out.println("Now at level: " + level + " counter = " + i);
        loop(level + 1, max_level, size);
    }
}

}

但这仍然使用递归。

Answer 5

这有点令人费解，但是：在没有递归的情况下，这是一种方法，在一个函数中没有if s。

public static void no_ifs_no_recursion(int n){  
    int[] helper = new int[n-1];
    int[] pointers = new int[n]; //helper for printing the results

    int totalsize = 1;
    for (int loops = 2; loops <= n; loops++){
        helper[n - loops] = totalsize;
        totalsize*=loops;
    }
    for (int i=0; i<totalsize; i++){
        int carry = i;
        for (int loops = 0; loops < n-1; loops++){
            pointers[loops] = carry/helper[loops];
            carry = carry - (pointers[loops]*helper[loops]);
        }

        System.out.println(Arrays.toString(pointers));
        //or do something else with `i` -> `pointers[0]`, `j` -> `pointers[1]`, `k` -> `pointers[2]` etc..
    }
}

动态更改嵌套for循环的数量

5 个答案: