Common Lisp中的简单递归示例:

MYMAP对列表中的每个元素应用一个函数。

1)空列表没有元素，所以我们返回空列表-()和NIL都是空列表。

2)将函数应用到第一个列表，对列表的其余部分调用MYMAP(递归调用)，并将两个结果合并到一个新列表中。

(DEFUN MYMAP (FUNCTION LIST)
  (IF (NULL LIST)
      ()
      (CONS (FUNCALL FUNCTION (FIRST LIST))
            (MYMAP FUNCTION (REST LIST)))))

让我们观察跟踪执行。在输入函数时，输出参数。在退出函数时，输出结果。对于每个递归调用，输出将按级别缩进。

这个例子对列表(1 2 3 4)中的每个数字调用SIN函数。

Command: (mymap 'sin '(1 2 3 4))

1 Enter MYMAP SIN (1 2 3 4)
| 2 Enter MYMAP SIN (2 3 4)
|   3 Enter MYMAP SIN (3 4)
|   | 4 Enter MYMAP SIN (4)
|   |   5 Enter MYMAP SIN NIL
|   |   5 Exit MYMAP NIL
|   | 4 Exit MYMAP (-0.75680256)
|   3 Exit MYMAP (0.14112002 -0.75680256)
| 2 Exit MYMAP (0.9092975 0.14112002 -0.75680256)
1 Exit MYMAP (0.841471 0.9092975 0.14112002 -0.75680256)

这是我们的结果:

(0.841471 0.9092975 0.14112002 -0.75680256)

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

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!意味着什么?如果不是: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

我希望这对你有所帮助

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

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

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

要向一个六岁的孩子解释递归，首先要向一个五岁的孩子解释，然后再等一年。

实际上，这是一个有用的反例，因为递归调用应该更简单，而不是更难。向一个5岁的孩子解释递归就更难了，尽管你可以在0点停止递归，但你没有简单的解决方案来向一个0岁的孩子解释递归。

要使用递归解决一个问题，首先将其细分为一个或多个可以用相同方法解决的更简单的问题，然后当问题简单到无需进一步递归就可以解决时，您可以返回到更高的级别。

事实上，这是用递归方法来解决问题的递归定义。