斐波那契数列的两种递归函数

Question

这是使用递归的斐波那契数列的原始代码

def rec(n):
if n<=1:
    return n
else:
    return ( rec(n-1) + rec(n-2))

n=int(input())

上面的代码在第 50 个学期左右变得非常慢。

下面我返回的​​代码基本上也是递归的。

n=int(input())
n1,n2,count=0,1,0
def rec(n,n1,n2,count):
    if count<n:
        print(n1)
        nth=n1 + n2
        n1=n2
        n2=nth
        count+=1
        rec(n,n1,n2,count)
rec(n,n1,n2,count)

我的问题是这两种方法都遵循递归（就像真正的递归）？

Answer 1

这两个函数都是递归的，但由于最后一个函数将调用自身作为函数中的最后一个动作，因此也被描述为尾递归。

尾递归函数可以很容易地转换成循环：

def rec(n, n1=0, n2=1, count=0):
    while count < n:
        print(n1)
        n1, n2, count = n2, n1 + n2, count +1

Answer 2

嗯，它们都是递归的，因为你在内部调用函数a()。因此，这两个函数的主要区别在于，第一个函数有两个递归调用，第二个函数只有一个。

那么现在，在另一件事上：

上面的代码在第 50 个学期左右变得非常慢。

嗯，你可以做一些有趣的事情来更快地完成它。看，由于斐波那契数列的递归定义，您正在做不止一个相同的计算。

例如：假设您要计算 fibonacci(5)，因此您需要计算 fibonacci(4) 和 fibonacci(3)。但是现在，对于fibonacci(4)，您需要计算fibonacci(3) 和fibonacci(2)，依此类推。但是等等，当你完成计算 fibonacci(4) 分支时，你已经计算了 3 和 2 的所有斐波那契，所以当你从第一个递归调用返回到另一个分支 (fibonacci(3)) 时，你已经计算了它。那么，如果有一种方法可以存储这些计算以便我可以更快地访问它们呢？您可以使用Decorators 创建一个memoize 类（某种内存以避免重复计算）：

这样我们会将fibonacci(k) 的每个计算存储在dict 上，并且我们将在每次调用之前检查它是否存在于字典中，如果True 则返回，否则计算它。这种方式更快

class memoize:
    def __init__(self, function):
        self.f = function
        self.memory = {}

    def __call__(self, *args):
        if args in self.memory:
            return self.memory[args]
        else:
            value = self.f(*args)
            self.memory[args] = value
            return value

@memoize
def fib(n):
  if n <= 1:
    return n
  else:
    return fib(n-1) + fib(n-2)

r = fib(50)
print(r)

您可以看到，没有memoization 花费的时间太长，而使用memoization 只花费了0.263614。

希望对你有帮助

Answer 3

如果一个函数调用自己，它被认为是递归的。

您的两个实现之间的区别在于，第一个实现大约 2**n 次调用自己，第二个调用自己大约 n 次。

对于 n = 50，2**50 是 1125899906842624。这是很多调用！难怪需要很长时间。 （例如：想想rec(10) 在计算rec(50) 时被调用的次数。很多很多很多次。）

虽然您的两个函数都是递归的，但我想说后者是“前向迭代”，因为您实际上是在通过斐波那契数列向前移动；对于您的第二个rec(50)，该函数仅递归大约 50 次。

一种使递归调用更快的技术称为memoization。见"Memoization" on Wikipedia。如果之前已经计算过答案，它会立即返回......因此不会“重新递归”。