递归函数就像弹簧，每次调用都要压缩一点。在每一步中，您将一些信息(当前上下文)放在堆栈上。当到达最后一步时，释放弹簧，立即收集所有值(上下文)!

不确定这个比喻是否有效…: -)

无论如何，除了经典的例子(阶乘是最糟糕的例子，因为它效率低，很容易被平化，Fibonacci, Hanoi…)，这些都有点人为(我很少，如果有的话，在实际编程案例中使用它们)，看看它真正被使用的地方是有趣的。

A very common case is to walk a tree (or a graph, but trees are more common, in general). For example, a folder hierarchy: to list the files, you iterate on them. If you find a sub-directory, the function listing the files call itself with the new folder as argument. When coming back from listing this new folder (and its sub-folders!), it resumes its context, to the next file (or folder). Another concrete case is when drawing a hierarchy of GUI components: it is common to have containers, like panes, to hold components which can be panes too, or compound components, etc. The painting routine calls recursively the paint function of each component, which calls the paint function of all the components it holds, etc.

不确定我是否很清楚，但我喜欢展示现实世界中教材的使用，因为这是我过去偶然发现的东西。

递归函数只是一个函数，它可以根据需要多次调用自己。如果您需要多次处理某件事，但不确定实际需要多少次，那么它就很有用。在某种程度上，你可以把递归函数看作是一种循环。然而，就像循环一样，您需要指定中断流程的条件，否则它将变得无限。

递归函数就像弹簧，每次调用都要压缩一点。在每一步中，您将一些信息(当前上下文)放在堆栈上。当到达最后一步时，释放弹簧，立即收集所有值(上下文)!

不确定这个比喻是否有效…: -)

无论如何，除了经典的例子(阶乘是最糟糕的例子，因为它效率低，很容易被平化，Fibonacci, Hanoi…)，这些都有点人为(我很少，如果有的话，在实际编程案例中使用它们)，看看它真正被使用的地方是有趣的。

A very common case is to walk a tree (or a graph, but trees are more common, in general). For example, a folder hierarchy: to list the files, you iterate on them. If you find a sub-directory, the function listing the files call itself with the new folder as argument. When coming back from listing this new folder (and its sub-folders!), it resumes its context, to the next file (or folder). Another concrete case is when drawing a hierarchy of GUI components: it is common to have containers, like panes, to hold components which can be panes too, or compound components, etc. The painting routine calls recursively the paint function of each component, which calls the paint function of all the components it holds, etc.

不确定我是否很清楚，但我喜欢展示现实世界中教材的使用，因为这是我过去偶然发现的东西。

构建递归函数的真正数学方法如下:

1:假设你有一个函数对f(n-1)是正确的，构造f使f(n)是正确的。 2:构造f，使得f(1)是正确的。

This is how you can prove that the function is correct, mathematically, and it's called Induction. It is equivalent to have different base cases, or more complicated functions on multiple variables). It is also equivalent to imagine that f(x) is correct for all x Now for a "simple" example. Build a function that can determine if it is possible to have a coin combination of 5 cents and 7 cents to make x cents. For example, it's possible to have 17 cents by 2x5 + 1x7, but impossible to have 16 cents. Now imagine you have a function that tells you if it's possible to create x cents, as long as x < n. Call this function can_create_coins_small. It should be fairly simple to imagine how to make the function for n. Now build your function: bool can_create_coins(int n) { if (n >= 7 && can_create_coins_small(n-7)) return true; else if (n >= 5 && can_create_coins_small(n-5)) return true; else return false; } The trick here is to realize that the fact that can_create_coins works for n, means that you can substitute can_create_coins for can_create_coins_small, giving: bool can_create_coins(int n) { if (n >= 7 && can_create_coins(n-7)) return true; else if (n >= 5 && can_create_coins(n-5)) return true; else return false; } One last thing to do is to have a base case to stop infinite recursion. Note that if you are trying to create 0 cents, then that is possible by having no coins. Adding this condition gives: bool can_create_coins(int n) { if (n == 0) return true; else if (n >= 7 && can_create_coins(n-7)) return true; else if (n >= 5 && can_create_coins(n-5)) return true; else return false; } It can be proven that this function will always return, using a method called infinite descent, but that isn't necessary here. You can imagine that f(n) only calls lower values of n, and will always eventually reach 0. To use this information to solve your Tower of Hanoi problem, I think the trick is to assume you have a function to move n-1 tablets from a to b (for any a/b), trying to move n tables from a to b.

我认为这个非常简单的方法可以帮助你理解递归。该方法将调用自身，直到某个条件为真，然后返回:

function writeNumbers( aNumber ){
 write(aNumber);
 if( aNumber > 0 ){
  writeNumbers( aNumber - 1 );
 }
 else{
  return;
 }
}

这个函数将输出从你输入的第一个数字到0的所有数字。因此:

writeNumbers( 10 );
//This wil write: 10 9 8 7 6 5 4 3 2 1 0
//and then stop because aNumber is no longer larger then 0

基本上发生的情况是writeNumbers(10)将写入10，然后调用writeNumbers(9)，后者将写入9，然后调用writeNumber(8)等。直到writeNumbers(1)写入1，然后调用writeNumbers(0)，这将写入0 butt将不会调用writeNumbers(-1);

这段代码本质上与以下代码相同:

for(i=10; i>0; i--){
 write(i);
}

你可能会问为什么要用递归，如果for循环本质上是一样的。当你需要嵌套for循环但不知道它们嵌套的深度时，你通常会使用递归。例如，当从嵌套数组中打印项目时:

var nestedArray = Array('Im a string', 
                        Array('Im a string nested in an array', 'me too!'),
                        'Im a string again',
                        Array('More nesting!',
                              Array('nested even more!')
                              ),
                        'Im the last string');
function printArrayItems( stringOrArray ){
 if(typeof stringOrArray === 'Array'){
   for(i=0; i<stringOrArray.length; i++){ 
     printArrayItems( stringOrArray[i] );
   }
 }
 else{
   write( stringOrArray );
 }
}

printArrayItems( stringOrArray );
//this will write:
//'Im a string' 'Im a string nested in an array' 'me too' 'Im a string again'
//'More nesting' 'Nested even more' 'Im the last string'

这个函数可以接受一个可以嵌套到100层的数组，而你写一个for循环就需要你嵌套它100次:

for(i=0; i<nestedArray.length; i++){
 if(typeof nestedArray[i] == 'Array'){
  for(a=0; i<nestedArray[i].length; a++){
   if(typeof nestedArray[i][a] == 'Array'){
    for(b=0; b<nestedArray[i][a].length; b++){
     //This would be enough for the nestedAaray we have now, but you would have
     //to nest the for loops even more if you would nest the array another level
     write( nestedArray[i][a][b] );
    }//end for b
   }//endif typeod nestedArray[i][a] == 'Array'
   else{ write( nestedArray[i][a] ); }
  }//end for a
 }//endif typeod nestedArray[i] == 'Array'
 else{ write( nestedArray[i] ); }
}//end for i

如你所见，递归方法要好得多。

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中进行更多的练习。