使用递归的斐波那契

Question

这是我用最少的处理能力解决“斐波那契数列的第 n 项”的想法-

int fibo(int n, int a, int b){
    return (n>0) ? fibo(n-1, b, a+b) : a;
}

main(){
    printf("5th term of fibo is %d", fibo(5 - 1, 0, 1));
}

打印所有术语，直到第 n 个术语，

int fibo(int n, int a, int b){
    printf("%d ", a);
    return (n>0)? fibo(n-1, b, a+b): a;
}

我向我的大学教授展示了这段代码，据她说，这是解决斐波那契问题的错误方法，因为这没有抽象方法。我应该将函数称为 fibo(n) 而不是 fibo(n, 0, 1)。这对我来说不是一个满意的答案，所以我想请教 SOF 方面的专家。

与解决斐波那契问题的传统方法相比，它有自己的优势。我们使用两个并行递归来获得斐波那契的第 n 项 (fibo(n-1) + fibo(n-2)) 的技术可能会很慢，无法给出系列的第 100 项，而我的技术即使在最坏的情况下也会快得多场景。

为了抽象它，我可以使用默认参数，但 C 不是这样。虽然我可以使用类似 -

int fibo(int n){return fiboN(n - 1, 0, 1);}
int fiboN(int n, int a, int b){return (n>0)? fiboN(n-1, b, a+b) : a;}

但是将整个想法抽象出来就足够了吗？我应该如何说服其他人这种方法没有错（虽然有点模糊）？

（我知道，这不是我应该在 SOF 上问的问题，但我只是想在这里得到专家的建议。）

Answer 1

虽然@rici 的回答大多令人满意，但我只是想分享我在解决这个问题时学到的知识。所以这是我对使用递归查找斐波那契的理解-

• 传统的实现fibo(n) { return (n < 2) n : fibo(n-1) + fibo(n-2);} 在时间和空间要求方面都非常低效。这不必要地构建堆栈。它需要 O(n) 堆栈空间和 O(rⁿ) 时间，其中 r = (√5 + 1)/2。
• 使用@Simion 的回答中建议的记忆技术，我们只需创建一个永久堆栈，而不是编译器在运行时创建的动态堆栈。因此内存需求保持不变，但时间复杂度以摊销的方式降低。但如果我们只需要使用一次它就没有帮助。
• 我在问题中建议的方法需要 O(1) 空间和 O(n) 时间。在这里，也可以使用相同的记忆技术以摊销的方式减少时间要求。
• 来自@rici 的帖子fib(2n) = fib(n)² + 2fib(n)fib(n - 1)，因为他建议时间复杂度降低到 O(log n)，我想，堆栈增长仍然是 O(n)。

所以我的结论是，如果我进行了适当的研究，时间复杂度和空间需求不能同时使用递归计算来降低。为了实现这两者，替代方案可以使用迭代，Matrix exponentiation or fast doubling。

Answer 2

作为旁注，您几乎可以在没有递归的情况下执行fibonacci problem，使其成为我所知道的最快的方法。代码在java中：

public int fibFor() {
    int sum = 0;
    int left = 0;
    int right = 1;
    for (int i = 2; i <= n; i++) {
        sum = left + right;
        left = right;
        right = sum;
    }
    return sum;
}

Answer 3

了解递归中的基本情况应该是a 而不是0，在我看来这是一个极好的（尽管不是最优的）解决方案。该函数中的递归是尾递归，因此一个好的编译器将能够避免堆栈增长，从而使函数 O(1) 稳定且 O(n) 时间（忽略数字大小的快速增长）。

你的教授是正确的，调用者不应该处理正确的初始化。所以你应该提供一个外部包装器来避免填写值的需要。

int fibo(int n, int a, int b) {
    return n > 0 ? fibo(b, a + b) : a;
}
int fib(int n) { return fibo(n, 0, 1); }

但是，提供和记录更通用的接口也很有用，以防调用者实际上想要改变初始值。

顺便说一下，有一种更快的计算技术，基于递归

fib(a + b - 1) = f(a)f(b) + f(a - 1)f(b - 1)

将b 替换为b + 1 会产生：

fib(a + b) = f(a)f(b + 1) + f(a - 1)f(b)

这些公式让我们一起计算：

fib(2n - 1) = fib(n + n - 1)
            = fib(n)² + fib(n - 1)²

fib(2n)     = fib(n + n)
            = fib(n)fib(n + 1) + fib(n - 1)fib(n)
            = fib(n)² + 2fib(n)fib(n - 1)

这允许计算以 O(log n) 步执行，每个步产生两个连续的值。

Answer 4

使用递归并以处理能力最低为目标，解决fibonacci() 的方法是让每个调用返回 2 个值。也许一个通过返回值，另一个通过int * 参数。

递归的通常想法是让一个顶级函数执行一次性准备和参数检查，然后是一个以精简方式编写的本地辅助函数。

---

以下内容遵循 OP 的 int fibo(int n) 和助手 int fiboN(int n, additional parameters) 的想法

递归深度是O(n)，内存使用也是O(n)。

static int fib1h(int n, int *previous) {
  if (n < 2) {
    *previous = n-1;
    return n;
  }
  int t;
  int sum = fib1h(n-1, &t);
  *previous = sum;
  return sum + t;
}

int fibo1(int n) {
  assert(n >= 0); // Handle negatives in some fashion
  int t;
  return fib1h(n, &t);
}

Answer 5

根据您的方法，您的结果将是 0。您只需进行递归，直到 n=0，然后返回 0。但是您还必须检查何时 n==1 并且您应该返回 1;你也有值 a 和 b 并且你对它们什么都不做。

我建议看看下面的递归函数，也许它会帮助你解决这个问题：

int fibo(int n){
    if(n < 2){
        return n;
    }
    else 
    {
       return (fibo(n-1) + fibo(n-2));    
    }
}

这是研究递归的经典问题。

EDIT1：根据@Ely 的建议，波纹管是一种优化的递归，具有记忆技术。当计算列表中的一个值时，它不会像第一个示例那样再次重新计算，但它会存储在数组中，并在需要时从该数组中取出：

const int MAX_FIB_NUMBER = 10;

int storeCalculatedValues[MAX_FIB_NUMBER] = {0};

int fibo(int n){

    if(storeCalculatedValues[n] > 0)
    {
        return storeCalculatedValues[n];
    }

    if(n < 2){
        storeCalculatedValues[n] = n;
    }
    else 
    {
       storeCalculatedValues[n] = (fibo(n-1) + fibo(n-2));
    }
    return storeCalculatedValues[n];
}

Answer 6

以最少的处理能力解决“斐波那契数列的第 n 项”

我可能不需要向你解释斐波那契数的递推关系。虽然你的教授给了你一个很好的暗示。

抽象出细节。她是对的。如果您想要第 n 个斐波那契数，只需告诉程序即可：Fibonacci(n)

由于您的目标是处理能力最低，因此您教授的提示也适用于称为 memoization 的技术，这基本上意味着 如果您计算了第 n 个斐波那契数，只需重复使用结果;无需重做计算。在文章中，您可以找到阶乘数的示例。

为此，您可能需要考虑存储第 n 个斐波那契数的数据结构；如果该内存已经有一个斐波那契数，则只需检索它，否则将计算出的斐波那契数存储在其中。

顺便说一句，在教学上没有帮助，但很有趣：还有一个 closed form expression 代表第 n 个斐波那契数。

这对我来说不是一个令人满意的答案，所以我想问 SOF 方面的专家。

“呃，你不认为你的教授是专家吗？”这是我的第一个想法。