定义递归函数的内容

what defines a recursive function?

本文关键字：递归函数定义更新时间：2023-10-16

除了这里提出的简单问题基于这个评论

问题是，即使实现的基本算法是递归的，解决方案在什么时候停止被认为是递归的？

为了完整性，所有情况下都使用以下功能：

int counter=0;
int reps=0;
void show(int x)
{
#ifdef OUTPUT
    printf("==============>>> %d <<<n", x);
#endif
    counter+=x;
    ++reps;
}
int bit_val(unsigned int v)
{
  static const int MultiplyDeBruijnBitPosition2[32] =
  {
    0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8,
    31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9
  };
  return MultiplyDeBruijnBitPosition2[(unsigned int)(v * 0x077CB531U) >> 27];
}

案例1：清除递归

void uniq_digitsR(int places, int prefix, int used) {
  if (places==1) {
    show(prefix*10+bit_val(~used));
    return;
  }
  int base=prefix*10;
  unsigned int unused=~used;
  while(unused) {
    unsigned int diff=unused & (unused-1);
    unsigned int bit=unused-diff;
    unused=diff;
    uniq_digitsR(places-1, base+bit_val(bit), used|bit);
  }
}
int uniq_digits9() {
  unsigned int used=~((1<<10)-1); // set all bits except 0-9
  used |= 1;                      // unset 0
  uniq_digitsR(9, 0, used);
  return 0;
}

案例2：硬编码展开

请注意，函数在任何时候都不会调用自身或任何直接或间接调用方

void uniq_digits1(int prefix, unsigned int used) {
  show(prefix*10+bit_val(~used));
}
void uniq_digits2(int prefix, unsigned int used) {
  int base=prefix*10;
  unsigned int unused=~used;
  while (unused) {
    unsigned int diff=unused & (unused-1);
    unsigned int bit=unused-diff;
    unused=diff;
    uniq_digits1(base+bit_val(bit), used|bit);
  }
}
void uniq_digits3(int prefix, unsigned int used) {
  int base=prefix*10;
  unsigned int unused=~used;
  while (unused) {
    unsigned int diff=unused & (unused-1);
    unsigned int bit=unused-diff;
    unused=diff;
    uniq_digits2(base+bit_val(bit), used|bit);
  }
}
void uniq_digits4(int prefix, unsigned int used) {
  int base=prefix*10;
  unsigned int unused=~used;
  while (unused) {
    unsigned int diff=unused & (unused-1);
    unsigned int bit=unused-diff;
    unused=diff;
    uniq_digits3(base+bit_val(bit), used|bit);
  }
}
void uniq_digits5(int prefix, unsigned int used) {
  int base=prefix*10;
  unsigned int unused=~used;
  while (unused) {
    unsigned int diff=unused & (unused-1);
    unsigned int bit=unused-diff;
    unused=diff;
    uniq_digits4(base+bit_val(bit), used|bit);
  }
}
void uniq_digits6(int prefix, unsigned int used) {
  int base=prefix*10;
  unsigned int unused=~used;
  while (unused) {
    unsigned int diff=unused & (unused-1);
    unsigned int bit=unused-diff;
    unused=diff;
    uniq_digits5(base+bit_val(bit), used|bit);
  }
}
void uniq_digits7(int prefix, unsigned int used) {
  int base=prefix*10;
  unsigned int unused=~used;
  while (unused) {
    unsigned int diff=unused & (unused-1);
    unsigned int bit=unused-diff;
    unused=diff;
    uniq_digits6(base+bit_val(bit), used|bit);
  }
}
void uniq_digits8(int prefix, unsigned int used) {
  int base=prefix*10;
  unsigned int unused=~used;
  while (unused) {
    unsigned int diff=unused & (unused-1);
    unsigned int bit=unused-diff;
    unused=diff;
    uniq_digits7(base+bit_val(bit), used|bit);
  }
}
void uniq_digits9() {
  unsigned int used=~((1<<10)-1); // set all bits except 0-9
  used |= 1;                      // unset 0
  for (int i = 1; i < 10; i++) {
    unsigned int bit=1<<i;
    uniq_digits8(i,used|bit);
  }
}

案例3：迭代版本

注意，没有调用任何函数(除了明显显示之外(，但它是相同的算法

void uniq_digits(const int array[], const int length) {
  unsigned int unused[length-1];                    // unused prior
  unsigned int combos[length-1];                    // digits untried
  int digit[length];                                // printable digit
  int mult[length];                                 // faster calcs
  mult[length-1]=1;                                 // start at 1
  for (int i = length-2; i >= 0; --i)
     mult[i]=mult[i+1]*10;                          // store multiplier
  unused[0]=combos[0]=((1<<(length))-1);            // set all bits 0-length
  int depth=0;                                      // start at top
  digit[0]=0;                                       // start at 0
  while(1) {
    if (combos[depth]) {                            // if bits left
      unsigned int avail=combos[depth];             // save old
      combos[depth]=avail & (avail-1);              // remove lowest bit
      unsigned int bit=avail-combos[depth];         // get lowest bit
      digit[depth+1]=digit[depth]+mult[depth]*array[bit_val(bit)]; // get associated digit
      unsigned int rest=unused[depth]&(~bit);       // all remaining
      depth++;                                      // go to next digit
      if (depth!=length-1) {                        // not at bottom
        unused[depth]=combos[depth]=rest;           // try remaining
      } else {
        show(digit[depth]+array[bit_val(rest)]);    // print it
        depth--;                                    // stay on same level
      }
    } else {
      depth--;                                      // go back up a level
      if (depth < 0)
        break;                                      // all done
    }
  }
}

那么，仅仅CASE 1是递归的吗？或者我们也包括CASE 2甚至CASE 3？

函数的递归定义与其迭代实现(或算法(之间存在差异。

函数可以以递归方式在数学上定义，但是计算该函数的算法(即实现(很可能是非递归的，反之亦然。

请注意，对于同一函数，可能存在不同的数学定义和不同的算法。

在您提供的示例中，很明显，CASE1-实现是递归的，而case2-和CASE3-实现不是递归的，无论函数的数学定义是否是递归的。

p。S.为了将其保留在问题的范围内，我有意不涉及直接/间接递归，也不涉及一些仅通过递归表达迭代的纯函数语言

当任何时候，对于任何输入，激活链中都不会出现任何函数的多个实例时，解决方案就会停止递归：不会重新输入任何函数。

"展开递归"是否是递归？这取决于我们谈论的是展开的解决方案所基于的概念，还是它的实现。

显然，实现不是递归的。

显然，函数的展开副本是基于递归实现的机械重复，并且该解决方案仍然表达了该解决方案的某些方面；当您查看代码时，很明显可以将其回滚到递归实现中。我们还可以根据算法的递归描述来验证该解决方案；也就是说，使用递归算法的描述作为指导，我们可以很容易地说服自己展开的实现是对是错。

很明显，展开的代码正是这样：递归解决方案的展开实现。我们不能否认与递归规范的连接，但我们必须承认递归没有发生。

递归一词在不同的上下文中使用。你有一个递归函数的简单定义，其中函数直接或间接调用自己，但在计算机科学中，你也会说一些关于过程的东西。

迭代过程基本上是一个原始递归函数。它是所有可以通过迭代或尾部递归定义的函数。示例：

int test (int x)
{
  return x + 1;
}
int factorial(int x)
{
   int a = 1;
   while( x > 1 ) {
       a *= x;
   }
   return a;
}
int factorial_aux(int x, int a)
{
   return x == 0 ? a : factorial_aux(x-1, a*x);
}

递归过程是指在处理过程中总是需要某种数据结构来保留数据以进行回溯的过程。这方面的一个例子可能是树遍历：

Node* search(Node* tree, int needle) {
  if( tree == NULL  || tree->value == needle )
    return tree;
  else
    return search(tree->left, needle) || search(tree->right, needle);
}
Node* search(Node* tree, int needle) {
  Stack<Node *> stack;
  if( tree )
    stack.push(tree);
  while ( stack.empty() == false ) {
      Node* n = stack.pop();
      if( n->value == needle )
          return n;
      if( tree->right != NULL )
         stack.push(tree->right);
      if( tree->left != NULL )
         stack.push(tree->left);
  }
  return NULL;
}

以上两个过程都是递归过程。一个使用递归函数，另一个使用循环的迭代函数，这一事实并没有改变系统堆栈或显式堆栈将随着进程访问离根更远的节点而增长的事实。

CPU通常不支持这些功能，因此编译器需要通过使用基元指令、推送和清理堆栈以进行参数传递来进行大量的"模拟"。因此，在引擎盖下，递归函数通常是一个堆栈不断增长的迭代过程。

因此，为了回答您的问题：

对于进程：当使用的空间为常量时
对于函数：当不可能进行直接或间接自调用时

只是扩展一下@AlexShesterov给出的答案。显式递归通常代价高昂，而且根据用例的不同，它有溢出堆栈的风险，这就是为什么在实践中，通常通过与您类似的转换来避免它。

考虑一个尾部递归函数。尾部递归函数，听起来像是一个在函数调用中不保持任何状态的函数(递归调用在末尾(。编译器通常会将这些代码作为迭代代码来实现，因为这是一个微不足道的转换。

递归是描述函数的一种非常简洁的方式，这就是为什么很多函数都是用它来描述的(即斐波那契数(。然而，在实践中，通常最好迭代地重新制定它们。

有了斐波那契数，你就。。。

F(0) = 0
F(1) = 1
F(N) = F(N-1) + F(N-2)

因此，通常在C++中，它可以用…递归实现。。。

size_t fib(size_t n) {
  if (n == 0)
    return 0;
  if (n == 1)
    return 1;
   return fib(n - 1) + fib(n - 2);
}

尽管如此，它的效率很低(重新计算值、将数据存储在调用堆栈上等(。一种优化方法是存储函数调用。然而，实际值可以自下而上构建，因此最好简单地迭代重新公式化。

size_t fib(size_t n) {
  size_t p = 0, c = 1;
  if (n == 0)
    return 0;
   while (n--) {
     size_t t = c;
     c = p + c;
     p = t;
   }
  return c;
}

为了好玩，哈斯克尔也有同样的东西。。。

fib n = fibs !! n
  where fibs = 0 : 1 : zipWith (+) fibs (tail fibs)