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

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，请在此代码路径之外使用它，并使用局部变量（或任务对象）将“局部静态”变量提供给您的关键代码路径。

Answer 2

您应该使用两种方法将其分开：一种是公共的，用于启动递归迭代并将计数器初始化为零，另一种是私有的，即进行递归调用的地方。这样每次调用公共方法时，计数器都会被初始化。它会是这样的（在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

考虑到索引被用作停止条件，我会采用简单的基于参数的方法。 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 4

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

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);
    }
}

从我得到的 cmets 中，您将其用作计数器，以检测何时结束递归。这看起来不是很有用。难道你没有一个可以从参数派生的条件，比如 list.length () 之类的吗？

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

但这比在柜台周围传递更多样板。

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

如果您想在调试时防止 stackoverflows，一个古玩的替代方法是调用随机化器，并在 10 000 个案例中返回一个。

Answer 5

最自然的做法是使用您在帖子中描述的辅助参数，特别是如果它用于确定何时停止递归。如果依赖于成员变量，您可以有一个帮助方法，在调用递归方法之前重置计数器，并在您想要调用递归函数时调用帮助方法。

如果您更喜欢使用单一方法，您必须执行以下操作：

创建一个名为insideMethod 的成员变量，默认设置为false。调用该方法时，它会检查此变量。如果它是假的，它是第一次调用，计数器应该被重置，否则计数器应该只是递增。之后，insideMethod 设置为 true。返回时，应将insideMethod 设置回 false，前提是 this 调用将其设置为 true。

记得将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
}