http://javabat.com是一个有趣而令人兴奋的练习递归的地方。他们的例子开始时相当简单，然后逐步扩展(如果你想这么做的话)。注意:他们的方法是在实践中学习。这是我写的一个递归函数，用来替换for循环。

for循环:

public printBar(length)
{
  String holder = "";
  for (int index = 0; i < length; i++)
  {
    holder += "*"
  }
  return holder;
}

这是做同样事情的递归。(请注意，我们重载了第一个方法，以确保它像上面那样使用)。我们还有另一种方法来维护索引(类似于上面的for语句)。递归函数必须维护自己的索引。

public String printBar(int Length) // Method, to call the recursive function
{
  printBar(length, 0);
}

public String printBar(int length, int index) //Overloaded recursive method
{
  // To get a better idea of how this works without a for loop
  // you can also replace this if/else with the for loop and
  // operationally, it should do the same thing.
  if (index >= length)
    return "";
  else
    return "*" + printBar(length, index + 1); // Make recursive call
}

简而言之，递归是一种编写更少代码的好方法。在后面的printBar中，请注意我们有一个if语句。如果我们的条件已经达到，我们将退出递归并返回到前一个方法，该方法返回到前一个方法，等等。如果我发送一个printBar(8)，我得到********。我希望通过一个简单函数的例子，它做的事情与for循环相同，这可能会有所帮助。不过，您可以在Java Bat中进行更多的练习。

实际上，使用递归是为了降低手头问题的复杂性。你应用递归，直到你达到一个简单的基本情况，可以很容易地解决。这样就可以解决最后一个递归步骤。用这些递归步骤就可以解决最初的问题。

想想工蜂。它试着酿蜂蜜。它完成了自己的工作，并期待其他工蜂来酿造剩下的蜂蜜。蜂房满了，蜂房就停了。

把它想象成魔法。你有一个与你要实现的函数同名的函数，当你给它子问题时，它就会帮你解决它，你唯一需要做的就是把你的部分的解与它给你的解集成起来。

例如，我们想计算一个列表的长度。让我们用magical_length来调用我们的函数，用magical_length来调用神奇的助手 我们知道，如果我们给出没有第一个元素的子列表，它会神奇地给我们子列表的长度。那么我们唯一需要考虑的就是如何将这些信息与我们的工作结合起来。第一个元素的长度是1，而magic_counter给出了子列表的长度n-1，因此总长度是(n-1) + 1 -> n

int magical_length( list )
  sublist = rest_of_the_list( list )
  sublist_length = magical_length( sublist ) // you can think this function as magical and given to you
  return 1 + sublist_length

然而，这个答案是不完整的，因为我们没有考虑如果我们给出一个空列表会发生什么。我们认为我们的列表总是至少有一个元素。因此，我们需要思考，如果给我们一个空列表，答案显然是0，那么答案应该是什么。所以把这些信息加到我们的函数中，这被称为基础/边缘条件。

int magical_length( list )
  if ( list is empty) then
    return 0
  else
    sublist_length = magical_length( sublist ) // you can think this function as magical and given to you
    return 1 + sublist_length

我会用一个例子来解释。

你知道n!意味着什么?如果不是:http://en.wikipedia.org/wiki/Factorial

3! Is 1 times 2 times 3, which is 6

下面是一些伪代码

function factorial(n) {
  if (n==0) return 1
  else return (n * factorial(n-1))
}

让我们试试吧:

factorial(3)

n是0吗?

no!

所以我们在递归中深入挖掘:

3 * factorial(3-1)

3 minus 1 is 2

2 == 0?

no!

所以我们要深入! 3 * 2 *阶乘(2-1) 2-1 = 1

1 == 0吗?

no!

所以我们要深入! 3 * 2 * 1 *阶乘(1-1) 1-1 = 0

0 == 0?

yes!

我们有一个小问题

所以我们有 3 * 2 * 1 * 1 = 6

我希望这对你有所帮助

Ouch. I tried to figure out the Towers of Hanoi last year. The tricky thing about TOH is it's not a simple example of recursion - you have nested recursions which also change the roles of towers on each call. The only way I could get it to make sense was to literally visualize the movement of the rings in my mind's eye, and verbalize what the recursive call would be. I would start with a single ring, then two, then three. I actually ordered the game on the internet. It took me maybe two or three days of cracking my brains to get it.

当使用递归解时，我总是尝试:

首先建立基本情况，即。 当n = 1的阶乘 试着想出一个一般的规则 对于其他情况

还有不同类型的递归解，分而治之的方法对分形和其他方法很有用。

如果你能先解决一些简单的问题，只是为了掌握窍门，这也会有帮助。一些例子是求解阶乘和生成第n个斐波那契数。

作为参考，我强烈推荐Robert Sedgewick的算法。

希望这能有所帮助。祝你好运。