如何在递归中使用索引变量？

Question

我想在递归中使用索引变量，而不在调用函数时将其作为参数发送。 但是，如果我在一开始将其重置（例如i = 0），它将在每次运行时重置。 我想将其用作计数器（对功能运行进行计数）。

Answer 1

首先，您显然只希望将其初始化一次。 递归的常见模式是：

public void run(int opt) {
  run_helper(opt, 0);
}

private void run(int opt, int depth) {
  if (whatever) { run(opt, depth + 1); }
}

外部方法除了初始化外什么都不做。

您经常会看到（例如在对问题的第一条评论中）建议使用的“解决方案”是使用静态变量。 这种方法是一种不好的风格，一旦添加多线程（例如，通过制作UI版本或在多线程Web服务器中运行它），就会导致程序以各种奇怪的方式失败。 最糟糕的是，一开始它似乎可以工作，并且只有在有许多用户的情况下，才开始巧妙地表现异常。 因此，除了常量之外，一切都不要使用“静态”！

使用“静态”，通常看起来像这样：

static int counter;

public void start() {
  counter = 0;
  recurse();
}

public void recurse() {
  counter += 1;
  if (whatever) { recurse(); }
}

现在想象两个用户调用同时start 。 他们会覆盖对方的柜台！ 因为静态意味着，它在线程和用户之间共享。

这是一个非常简单易懂的解决方案 ：

class MyTask {
  int counter = 0;

  public void recurse() {
    counter++;
    if (whatever) { recurse(); }
  }

  public int getIterations() {
    return counter;
  }
}

public void run() {
  MyTask task = new MyTask();
  task.run();
  System.out.println("Task took "+task.getIterations()+" itertions.");
}

然后，您创建一个任务，运行它，并在最后检索计数器。 清洁，简单，高效，可靠。 如果您有多个线程/用户，则每个线程/用户都有一个单独的MyTask对象，并且不会遇到任何问题。

另外，您可以添加其他统计信息，并且这些统计信息都干净地包装在任务对象中。 “每次迭代的平均时间”？ “平均递归深度”？ 没问题。 任务对象也可以用于存储结果。

建议在这里使用ThreadLocal 。 我不同意这一点。 它根本没有提供任务对象的任何好处。 只需尝试使用ThreadLocal和任务对象来实现它，您就会发现区别。 另外，凭经验， ThreadLocal比访问堆值慢10倍（请参阅https://stackoverflow.com/a/4756605/1060350 ）。 对于int来说，情况可能更糟。 因此， 永远不要在性能关键的代码路径中调用ThreadLocal#get 。 如果打算使用ThreadLocal ，请在此代码路径之外使用它，并使用局部变量（或Task对象）将“局部静态”变量馈送到关键代码路径中。

Answer 2

您应该使用两种方法将其分开：一种是公共的，以启动递归迭代并将计数器初始化为零；另一种是私有的，即进行递归调用的位置。 这样，每次您调用public方法时，计数器都会初始化。 就像这样（在Java中）：

public class Recursion{
    private int iterations=0;

    private int calcFactorial(int n){
        iterations++;
        if (n==2)
            return 2;
        else
            return n * calcFactorial(n-1);
    }

    public int factorial(int n){
        //initialize the counter
        iterations = 0;
        return calcFactorial(n);
    }

    public int getIterations(){
        return iterations;
    }
}

Answer 3

最自然的做法是，在您的帖子中描述一个辅助参数，尤其是当它用于确定何时停止递归时。 如果依赖于成员变量，则可以有一个帮助程序方法，该方法可以在调用递归方法之前重置计算机，并在需要调用递归函数时调用帮助程序方法。

如果您想坚持使用单一方法 ，则必须执行以下操作：

创建一个名为insideMethod的成员变量，默认情况下将其设置为false。 调用该方法时，它将检查此变量。 如果为假，则是第一个调用，应重置计数器，否则应将计数器递增。 之后，将insideMethod设置为true。 返回时，仅当此调用将它设置为true时，才应将insideMethod设置为false。

记住要使insideMethod和索引变量ThreadLocal。

伪代码：

ThreadLocal<Boolean> insideMethod = false
ThreadLocal<Integer> index = 0

....

void recMethod(args) {
    boolean topCall = (insideMethod == false)
    insideMethod = true

    if (topCall)
        index = 0
    else
        index++

    // Body of the method...

    if (topCall)
        insideMethod = false
}

Answer 4

考虑到将索引用作停止条件，我将采用一种基于参数的简单方法。 JavaScript实现：

var recurse = function() {
    recurseHelper(0);
};

var recurseHelper = function(iteration) {
    // run for 100 iterations, 
    if (iterationCount > 100)
        return;

    // do stuff...


    recurseHelper(iteration + 1);
}

但是，如果您只想多次调用某个函数，那么为什么要特别使用递归呢？ 您可以只使用一个循环。 再次在JavaScript中：

for (var i = 0; i < 100; i++) {
    // do stuff...
}

取决于递归算法的复杂性，与展开构造相比，与展开构造相比，编译器可以带来更多的乐趣。

Answer 5

您可以使用属性，但是为什么呢？ 为什么不将值作为参数传递？

public class Empty {

    private int steps = 0;  

    public static void main (String args [])
    {
        Empty e = new Empty ();
        System.out.println (e.reverse ("This is a test"));
        System.out.println ("steps: " + e.steps);
    }

    public String reverse (String s) {
        ++steps;
        if (s.length () < 2) 
            return s;
        else return reverse (s.substring (1)) + s.charAt (0);
    }
}

从我得到的评论中，您可以将其用作计数器，以检测何时结束递归。 看起来不太有用。 您是否没有可以从参数（例如list.length（）或类似参数）派生的条件？

当然，两次调用该方法将进一步增加计数器。 如果两个线程不能同时使用它，则可以重置它，而内部对象中的包装方法可能有助于防止在不首先重置计数器的情况下调用它。

但这比传递计数器要简单得多。

参数是用于计数调用的更简洁的解决方案。

如果要在调试时防止堆栈溢出，可替代方案是调用一个随机变量，并在万分之一的情况下返回。