什么是递归，我应该什么时候使用它？

Question

邮件列表和在线讨论中似乎经常出现的主题之一是攻读计算机科学学位的优点（或不足）。反对方似乎一次又一次提出的一个论点是，他们已经编码了几年并且从未使用过递归。

所以问题是：

1. 什么是递归？
2. 什么时候使用递归？
3. 为什么人们不使用递归？

Answer 1

在这个线程中有很多关于recursion 的很好的解释，这个答案是关于为什么你不应该在大多数语言中使用它。* 在大多数主要的命令式语言实现中（即 C 的每个主要实现， C++、Basic、Python、Ruby、Java 和 C#）iteration 比递归更可取。

要了解原因，请浏览上述语言用于调用函数的步骤：

1. the stack 上为函数的参数和局部变量留出了空间
2. 函数的参数被复制到这个新空间中
3. 控制跳转到函数
4. 函数的代码运行
5. 函数的结果被复制到返回值中
6. 堆栈被倒回到之前的位置
7. 控制跳回到调用函数的地方

完成所有这些步骤需要时间，通常比遍历循环所花费的时间多一点。然而，真正的问题在于步骤#1。当许多程序启动时，它们会为其堆栈分配一块内存，当它们用完该内存时（通常但不总是由于递归），程序会因stack overflow 而崩溃。

因此，在这些语言中，递归速度较慢，并且容易崩溃。尽管如此，仍然有一些使用它的论据。一般来说，一旦您知道如何阅读，递归编写的代码会更短且更优雅。

语言实现者可以使用一种称为tail call optimization 的技术，它可以消除某些类别的堆栈溢出。简而言之：如果一个函数的返回表达式只是一个函数调用的结果，那么您不需要在堆栈上添加新的级别，您可以将当前的级别重用于被调用的函数。遗憾的是，很少有命令式语言实现内置了尾调用优化。

* 我喜欢递归。 My favorite static language 根本不使用循环，递归是重复做某事的唯一方法。我只是不认为在没有针对它进行调整的语言中，递归通常不是一个好主意。

** 顺便说一下，Mario，您的 ArrangeString 函数的典型名称是“join”，如果您选择的语言还没有实现它，我会感到惊讶。

Answer 2

递归的简单英文例子。

A child couldn't sleep, so her mother told her a story about a little frog,
    who couldn't sleep, so the frog's mother told her a story about a little bear,
         who couldn't sleep, so the bear's mother told her a story about a little weasel... 
            who fell asleep.
         ...and the little bear fell asleep;
    ...and the little frog fell asleep;
...and the child fell asleep.

Answer 3

在最基本的计算机科学意义上，递归是一个调用自身的函数。假设你有一个链表结构：

struct Node {
    Node* next;
};

你想知道一个链表有多长，你可以用递归做到这一点：

int length(const Node* list) {
    if (!list->next) {
        return 1;
    } else {
        return 1 + length(list->next);
    }
}

（这当然也可以通过 for 循环来完成，但作为概念的说明很有用）

Answer 4

每当一个函数调用自己，创建一个循环，那就是递归。与任何事物一样，递归也有好的用途和坏的用途。

最简单的例子是尾递归，函数的最后一行是对自身的调用：

int FloorByTen(int num)
{
    if (num % 10 == 0)
        return num;
    else
        return FloorByTen(num-1);
}

然而，这是一个蹩脚的、几乎毫无意义的例子，因为它很容易被更有效的迭代所取代。毕竟，递归会受到函数调用开销的影响，在上面的示例中，与函数内部的操作相比，这可能是相当大的。

所以进行递归而不是迭代的全部原因应该是利用call stack 做一些聪明的事情。例如，如果您在同一个循环中多次调用具有不同参数的函数，那么这是完成branching 的一种方式。一个经典的例子是Sierpinski triangle。

您可以使用递归非常简单地绘制其中一个，其中调用堆栈在 3 个方向上分支：

private void BuildVertices(double x, double y, double len)
{
    if (len > 0.002)
    {
        mesh.Positions.Add(new Point3D(x, y + len, -len));
        mesh.Positions.Add(new Point3D(x - len, y - len, -len));
        mesh.Positions.Add(new Point3D(x + len, y - len, -len));
        len *= 0.5;
        BuildVertices(x, y + len, len);
        BuildVertices(x - len, y - len, len);
        BuildVertices(x + len, y - len, len);
    }
}

如果您尝试用迭代做同样的事情，我想您会发现需要更多的代码才能完成。

其他常见用例可能包括遍历层次结构，例如网站爬虫、目录比对等

结论

实际上，当您需要迭代分支时，递归最有意义。

Answer 5

递归是一种基于分而治之思维的解决问题的方法。 基本思想是你把原始问题分成更小的（更容易解决的）实例，解决那些更小的实例（通常再次使用相同的算法），然后将它们重新组合成最终的解决方案。

典型示例是生成 n 的阶乘的例程。 n 的阶乘是通过将 1 和 n 之间的所有数字相乘来计算的。 C# 中的迭代解决方案如下所示：

public int Fact(int n)
{
  int fact = 1;

  for( int i = 2; i <= n; i++)
  {
    fact = fact * i;
  }

  return fact;
}

迭代解决方案并不令人惊讶，任何熟悉 C# 的人都应该理解它。

通过识别第 n 个阶乘是 n * Fact(n-1) 来找到递归解决方案。或者换一种说法，如果你知道一个特定的阶乘数是什么，你就可以计算下一个阶乘数。这是 C# 中的递归解决方案：

public int FactRec(int n)
{
  if( n < 2 )
  {
    return 1;
  }

  return n * FactRec( n - 1 );
}

这个函数的第一部分被称为Base Case（或者有时是Guard Clause），它可以防止算法永远运行。每当使用 1 或更小的值调用函数时，它只会返回值 1。第二部分更有趣，被称为递归步骤。在这里，我们使用稍微修改的参数调用相同的方法（我们将其减 1），然后将结果与我们的 n 副本相乘。

第一次遇到这种情况时可能会让人感到困惑，因此在运行时检查它的工作原理会很有启发性。假设我们调用 FactRec(5)。我们进入了例程，没有被基本情况所接受，所以我们最终是这样的：

// In FactRec(5)
return 5 * FactRec( 5 - 1 );

// which is
return 5 * FactRec(4);

如果我们重新输入带有参数 4 的方法，我们又不会被保护子句停止，所以我们最终会：

// In FactRec(4)
return 4 * FactRec(3);

如果我们把这个返回值代入上面的返回值，我们得到

// In FactRec(5)
return 5 * (4 * FactRec(3));

这应该会为您提供有关如何得出最终解决方案的线索，以便我们快速跟踪并展示下降过程中的每一步：

return 5 * (4 * FactRec(3));
return 5 * (4 * (3 * FactRec(2)));
return 5 * (4 * (3 * (2 * FactRec(1))));
return 5 * (4 * (3 * (2 * (1))));

当基本情况被触发时，会发生最终的替换。在这一点上，我们有一个简单的代数公式来求解，它首先直接等同于阶乘的定义。

请注意，对方法的每次调用都会导致触发基本情况或调用参数更接近基本情况的同一方法（通常称为递归调用）。如果不是这种情况，那么该方法将永远运行。

Answer 6

递归是通过调用自身的函数来解决问题。一个很好的例子是阶乘函数。阶乘是一个数学问题，其中 5 的阶乘是 5 * 4 * 3 * 2 * 1。这个函数在 C# 中解决了这个正整数问题（未经测试 - 可能存在错误）。

public int Factorial(int n)
{
    if (n <= 1)
        return 1;

    return n * Factorial(n - 1);
}

Answer 7

递归是指通过解决问题的较小版本然后使用该结果加上一些其他计算来制定原始问题的答案来解决问题的方法。很多时候，在解决较小版本的过程中，该方法会解决问题的较小版本，依此类推，直到达到一个容易解决的“基本情况”。

例如，要计算数字X 的阶乘，可以将其表示为X times the factorial of X-1。因此，该方法“递归”以找到X-1 的阶乘，然后将得到的任何值乘以X 以给出最终答案。当然，要找到X-1 的阶乘，首先要计算X-2 的阶乘，以此类推。基本情况是X 为 0 或 1，在这种情况下，它知道返回 1，因为0! = 1! = 1。