介绍

斐波那契数列是一种经典的递归数列，根据斐波那契数列的数学定义，其第n项F(n)定义如下:

F(0) = F(1) = 1
F(n) = F(n-1) + F(n-2), n > 1

算法实现

我们可以根据上面的推导公式，直接写出一个递归算法

递归实现

def fib(b):
    if n < 2:
        return 1
    else:
        return fib(n-1) + fib(n-2)

把参数n看做问题实例的规模，不难看出F(n)的时间代价大致等于计算F(n-1)和F(n-2)的时间代价只和。根据已有的结论：

通项公式

斐波那契数列计算F(n)的时间代价按n值的指数增长。对于较大的n, 这一计算就需要很长很长时间。所以一般不推荐这种实现。

递推实现

求斐波那契数还有另一个简单的递推算法：对于F(0)和F(1)(如果n等于0或1）直接给出结果1；否则从F(k-1)和F(k-2)递推计算F(k)， 直到k等于n时就得到了F(n):

def  fib(n):
    f1 = f2 = 1
    for k in range(1, n):
        f1, f2 = f2, f2 + f1
    return f2

用这个算法计算F(n)的值，循环前的工作只做一次，循环需要做n-1次，因此时间复杂度为O(n)。

实验验证

我们编写如下代码验证以上两种算法：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import time

def log_cost_time(func):
    def wrapped(*args, **kwargs):
        import time
        begin = time.time()
        try:
            return func(*args, **kwargs)
        finally:
            print('func %s cost %s s' % (func.__name__, time.time() - begin))
    return wrapped


class Solution(object):
    @log_cost_time
    def fib_with_recursion(self, n):
        def _fib(n):
            if n < 2:
                return 1
            else:
                return _fib(n - 1) + _fib(n -2 )
        ret = _fib(n)
        return ret

    @log_cost_time
    def fib_with_recurrence(self, n):
        f1 = f2 = 1
        for _ in range(1, n):
            f1, f2 = f2, f2 + f1
        return f2



if __name__ == '__main__':
    s = Solution()
    print(s.fib_with_recursion(35))
    print(s.fib_with_recurrence(35))    

输出结果为：

func fib_with_recursion cost 5.395308494567871 s
14930352
func fib_with_recurrence cost 0.0 s
14930352

可以看出，递归算法花费的时间远远高于递推算法。

其他

算法代码大家可以去github上下载。