理解递归

你如何倒空一个装有五朵花的花瓶?

答:如果花瓶不是空的，你就拿出一朵花然后你倒空了一个装有四朵花的花瓶。

你如何倒空一个装有四朵花的花瓶?

答:如果花瓶不是空的，你就拿出一朵花然后你倒空了一个装有三朵花的花瓶。

你如何倒空一个装有三朵花的花瓶?

答:如果花瓶不是空的，你就拿出一朵花然后你把装着两朵花的花瓶倒空。

你如何倒空一个装有两朵花的花瓶?

答:如果花瓶不是空的，你就拿出一朵花然后你把只装了一朵花的花瓶倒空。

你如何清空只装了一朵花的花瓶?

答:如果花瓶不是空的，你就拿出一朵花然后你倒空了一个没有花的花瓶。

你怎么倒空一个没有花的花瓶?

答:如果花瓶不是空的，你就拿出一朵花但是花瓶是空的，所以你完成了。

这是重复的。让我们概括一下:

你如何倒空一个装有N朵花的花瓶?

答:如果花瓶不是空的，你就拿出一朵花然后你倒空一个装有N-1朵花的花瓶。

嗯，我们能看看代码吗?

void emptyVase( int flowersInVase ) {
  if( flowersInVase > 0 ) {
   // take one flower and
    emptyVase( flowersInVase - 1 ) ;

  } else {
   // the vase is empty, nothing to do
  }
}

我们不能在for循环中做这个吗?

为什么，是的，递归可以用迭代代替，但通常递归更优雅。

让我们来谈谈树。在计算机科学中，树是由节点组成的结构，其中每个节点都有一定数量的子节点，这些子节点也是节点或null。二叉树是由恰好有两个子结点组成的树，通常称为“左”和“右”;同样，子节点可以是节点，也可以为空。根节点不是任何其他节点的子节点。

假设一个节点，除了它的子节点外，还有一个值，一个数字，然后假设我们想要在某个树中对所有的值求和。

为了对任意一个节点的值求和，我们将节点本身的值与它左子节点的值(如果有的话)和右子节点的值(如果有的话)相加。现在回想一下，如果子节点不为空，它们也是节点。

因此，要对左子节点求和，我们需要将子节点自身的值与左子节点的值(如果有的话)以及右子节点的值(如果有的话)相加。

因此，要对左子节点的左子节点的值求和，我们需要将子节点自身的值与它的左子节点的值(如果有的话)以及它的右子节点的值(如果有的话)相加。

也许您已经预料到我要做什么，并希望看到一些代码?好:

struct node {
  node* left;
  node* right;
  int value;
} ;

int sumNode( node* root ) {
  // if there is no tree, its sum is zero
  if( root == null ) {
    return 0 ;

  } else { // there is a tree
    return root->value + sumNode( root->left ) + sumNode( root->right ) ;
  }
}

请注意，我们没有显式地测试子节点以确定它们是空节点还是节点，而是让递归函数对于空节点返回零。

假设我们有一个这样的树(数字是值，斜杠指向子结点，@表示指针指向null):

     5
    / \
   4   3
  /\   /\
 2  1 @  @
/\  /\
@@  @@

如果我们在根节点(值为5的节点)上调用sumNode，我们将返回:

return root->value + sumNode( root->left ) + sumNode( root->right ) ;
return 5 + sumNode( node-with-value-4 ) + sumNode( node-with-value-3 ) ;

我们把它展开。在任何我们看到sumNode的地方，我们都将它替换为return语句的展开:

sumNode( node-with-value-5);
return root->value + sumNode( root->left ) + sumNode( root->right ) ;
return 5 + sumNode( node-with-value-4 ) + sumNode( node-with-value-3 ) ;

return 5 + 4 + sumNode( node-with-value-2 ) + sumNode( node-with-value-1 ) 
 + sumNode( node-with-value-3 ) ;  

return 5 + 4 
 + 2 + sumNode(null ) + sumNode( null )
 + sumNode( node-with-value-1 ) 
 + sumNode( node-with-value-3 ) ;  

return 5 + 4 
 + 2 + 0 + 0
 + sumNode( node-with-value-1 ) 
 + sumNode( node-with-value-3 ) ; 

return 5 + 4 
 + 2 + 0 + 0
 + 1 + sumNode(null ) + sumNode( null )
 + sumNode( node-with-value-3 ) ; 

return 5 + 4 
 + 2 + 0 + 0
 + 1 + 0 + 0
 + sumNode( node-with-value-3 ) ; 

return 5 + 4 
 + 2 + 0 + 0
 + 1 + 0 + 0
 + 3 + sumNode(null ) + sumNode( null ) ; 

return 5 + 4 
 + 2 + 0 + 0
 + 1 + 0 + 0
 + 3 + 0 + 0 ;

return 5 + 4 
 + 2 + 0 + 0
 + 1 + 0 + 0
 + 3 ;

return 5 + 4 
 + 2 + 0 + 0
 + 1 
 + 3  ;

return 5 + 4 
 + 2 
 + 1 
 + 3  ;

return 5 + 4 
 + 3
 + 3  ;

return 5 + 7
 + 3  ;

return 5 + 10 ;

return 15 ;

现在看看我们是如何通过将其视为复合模板的重复应用来征服任意深度和“分支性”的结构的。每次通过我们的sumNode函数，我们只处理一个节点，使用一个单一的if/then分支，和两个简单的返回语句，几乎自己写，直接从我们的规范?

How to sum a node:
 If a node is null 
   its sum is zero
 otherwise 
   its sum is its value 
   plus the sum of its left child node
   plus the sum of its right child node

这就是递归的力量。

上面的花瓶例子是尾递归的一个例子。尾递归的意思是，在递归函数中，如果我们递归(也就是说，如果我们再次调用这个函数)，这是我们做的最后一件事。

树的例子不是尾递归，因为尽管我们最后做的是递归右子结点，但在这之前我们递归了左子结点。

事实上，我们调用子节点的顺序，以及添加当前节点值的顺序根本不重要，因为加法是可交换的。

现在让我们来看一个顺序很重要的操作。我们将使用节点的二叉树，但这次保存的值将是一个字符，而不是一个数字。

我们的树将有一个特殊的属性，即对于任何节点，其字符都在其左子字符之后(按字母顺序)，在其右子字符之前(按字母顺序)。

我们要做的是按字母顺序打印树。考虑到树的特殊性质，这很容易做到。我们只打印左子节点，然后是节点的字符，然后是右子节点。

我们不想随意地打印，所以我们会给函数传递一些东西来打印。这将是一个带有print(char)函数的对象;我们不需要担心它是如何工作的，只需要知道当print被调用时，它会在某个地方打印一些东西。

让我们看看代码:

struct node {
  node* left;
  node* right;
  char value;
} ;

// don't worry about this code
class Printer {
  private ostream& out;
  Printer( ostream& o ) :out(o) {}
  void print( char c ) { out << c; }
}

// worry about this code
int printNode( node* root, Printer& printer ) {
  // if there is no tree, do nothing
  if( root == null ) {
    return ;

  } else { // there is a tree
    printNode( root->left, printer );
    printer.print( value );
    printNode( root->right, printer );
}

Printer printer( std::cout ) ;
node* root = makeTree() ; // this function returns a tree, somehow
printNode( root, printer );

除了运算的顺序现在很重要之外，这个例子还说明了我们可以将东西传递到递归函数中。我们要做的唯一一件事就是确保在每次递归调用时，我们继续传递它。我们将一个节点指针和一个打印机传递给函数，在每次递归调用时，我们将它们“向下”传递。

如果我们的树是这样的

         k
        / \
       h   n
      /\   /\
     a  j @  @
    /\ /\
    @@ i@
       /\
       @@

我们要打印什么?

From k, we go left to
  h, where we go left to
    a, where we go left to 
      null, where we do nothing and so
    we return to a, where we print 'a' and then go right to
      null, where we do nothing and so
    we return to a and are done, so
  we return to h, where we print 'h' and then go right to
    j, where we go left to
      i, where we go left to 
        null, where we do nothing and so
      we return to i, where we print 'i' and then go right to
        null, where we do nothing and so
      we return to i and are done, so
    we return to j, where we print 'j' and then go right to
      null, where we do nothing and so
    we return to j and are done, so
  we return to h and are done, so
we return to k, where we print 'k' and then go right to
  n where we go left to 
    null, where we do nothing and so
  we return to n, where we print 'n' and then go right to
    null, where we do nothing and so
  we return to n and are done, so 
we return to k and are done, so we return to the caller

如果我们只看打印出来的行

    we return to a, where we print 'a' and then go right to
  we return to h, where we print 'h' and then go right to
      we return to i, where we print 'i' and then go right to
    we return to j, where we print 'j' and then go right to
we return to k, where we print 'k' and then go right to
  we return to n, where we print 'n' and then go right to

我们看到我们打印了“ahijkn”，它确实是按字母顺序排列的。

我们只需知道如何按字母顺序打印单个节点，就可以按字母顺序打印整个树。这只是(因为我们的树具有将值按字母顺序排在后面的值的左边的特殊属性)知道在打印节点的值之前打印左子节点，在打印节点的值之后打印右子节点。

这就是递归的力量:能够通过只知道如何做整体的一部分来完成整个事情(并且知道何时停止递归)。

回想一下，在大多数语言中，操作符|| ("or")在第一个操作数为真时短路，一般递归函数为:

void recurse() { doWeStop() || recurse(); }

Luc M评论道:

SO应该为这种回答创建一个徽章。恭喜你!

谢谢,吕克·!但实际上，因为我编辑了不止四次这个答案(为了添加最后一个例子，但主要是为了纠正错字和润色——在一个小小的上网本键盘上打字很困难)，我无法从这个答案中获得更多的分数。这在一定程度上阻碍了我在未来的答案上花那么多精力。

请看我的评论:https://stackoverflow.com/questions/128434/what-are-community-wiki-posts-in-stackoverflow/718699#718699

2009-04-04 21:19:46

子函数隐式地使用递归，例如:

去迪士尼乐园自驾游

我们到了吗?(没有) 我们到了吗?(很快) 我们到了吗?(快了……) 我们到了吗? 我们到了吗?(!!!!!)

这时孩子就睡着了……

这个倒数函数是一个简单的例子:

倒计时()函数｛返回(参数[0]> 0 ? （ Console.log(参数[0])，倒计时(参数[0]- 1)): “完成” ）; ｝倒计时(10);

霍夫施塔特定律也适用于软件项目。

The essence of human language is, according to Chomsky, the ability of finite brains to produce what he considers to be infinite grammars. By this he means not only that there is no upper limit on what we can say, but that there is no upper limit on the number of sentences our language has, there's no upper limit on the size of any particular sentence. Chomsky has claimed that the fundamental tool that underlies all of this creativity of human language is recursion: the ability for one phrase to reoccur inside another phrase of the same type. If I say "John's brother's house", I have a noun, "house", which occurs in a noun phrase, "brother's house", and that noun phrase occurs in another noun phrase, "John's brother's house". This makes a lot of sense, and it's an interesting property of human language.

参考文献

递归与人类思想

2012-08-30 23:26:04

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

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.

2009-04-05 11:49:26

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

2009-04-04 21:04:37