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

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

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

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

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

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

你在用哪本书?

关于算法的标准教科书是Cormen & Rivest。我的经验是，它很好地教授了递归。

递归是编程中较难掌握的部分之一，虽然它确实需要本能，但它是可以学习的。但它确实需要一个好的描述，好的例子和好的插图。

此外，30页通常是很多的，30页是用一种编程语言编写的。在你从一本普通的书中理解递归之前，不要尝试用C或Java学习递归。

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.

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

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

例如，我们想计算一个列表的长度。让我们用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

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

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.

这与其说是一个问题，不如说是一个抱怨。关于递归你有更具体的问题吗?就像乘法一样，人们不会写很多关于它的东西。

说到乘法，想想这个。

问题:

* b是什么?

答:

如果b = 1，就是a。 否则就是a+a*(b-1)

* (b - 1)是什么?请参考上面的问题来解决这个问题。