剑指offer：Python 斐波那契数列 最全的斐波那契数列解法

斐波那契数列

• 斐波那契数列（Fibonacci sequence），又称黄金分割数列、因数学家列昂纳多·斐波那契
  （Leonardoda Fibonacci）以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：1、1、2、3、5、8、13、21、34、……在数学上，斐波那契数列以如下被以递推的方法定义：F(1)=1，F(2)=1, F(n)=F(n-1)+F(n-2)（n>=3，n∈N*）
  这个数列从第3项开始，每一项都等于前两项之和

Python实现

递归实现

一般递归

裴波那契数列：F(0)=0，F(1)=1，F(2)=1, F(n)=F(n-1)+F(n-2)，根据数列特点，可以利用递归

class Solution:
    def fibonacci(self, n):
        if n == 0:
            return 0
        if n == 1 or n == 2:
            return 1
        if n > 1:
            return self.Fibonacci(n - 1) + self.Fibonacci(n - 2)
        return None


obj = Solution()
print(obj.fibonacci(10)) # 55
'''
这种做法可以实现，但是非常不值得推荐，可以说是非常严重！O(n)=2^n
'''

图解 递归的过程

尾递归

# 使用尾递归法求解斐波那契数量的第num个数字
def fibonacci(num, res, temp):
    if num == 0:
        return res
    else:
        return fibonacci(num - 1, temp, res + temp)


print(fibonacci(10, 0, 1))

'''
在求第1000个时，爆掉，递归还是有局限性的
'''

补充 尾递归 例题：求输入一个数n的阶乘

动态规划

以下的解法是提倡的最优解法

动态规划（1）

• 当n>1时，有 f(n)=f(n-1)+f(n-2)
  假设： n=2时，即是： f(2)=f(1)+f(0) ；n=3时 即是： f(3)=f(2)+f(1)

• 我们用两个数来保存每一次的值，a 用来保存一个大值，b 用来保存一个小值
  即是：↓↓↓
  f(2)=a+b →f(2) = f(1) + f(0) 其中 a保存了f(1) 的值，b保存了f(0)的值
  f(3)=a+b →f(3) = f(2) + f(1) 此时 a = f(2)，f(2)是上一步的和，f(1)即是上一次的 a
  即是：f(3)= a+b =(a’+b’)+a’

时间复杂度为：O(n)

def fibonacci(n):
    if n == 0:
        return 0
    if n == 1:
        return 1
    if n > 1:
        a = 1
        b = 0
        ret = 0
        for i in range(2, n+1):
            ret = a + b
            b = a
            a = ret
        return ret


print(fibonacci(10)) # 55 

# 换一种写法
def fibonacci(n):
    if n == 0:
        return 0
    if n == 1:
        return 1
    result = [0, 1]  # 利用一个列表，来存储之前的所有的裴波那契数列
    for i in range(2, n + 1):  # 产生 n-1个数
        result.append(result[i - 1] + result[i - 2])
    return result[-1]  # 返回列表的最后一个元素，即数列的第n项


print(fibonacci(10))
'''
result=[0,1] 就是第一种写法的 a 和 b ，前者存放小的值，后者存放大的值
后者大的值，就是最终的结果，所以result[-1]

因为后一项一直用到前面的数，所以时间复杂度为O(n)
'''

动态规划（2）

class Solution:
    def Fibonacci(self, n):
        if n == 0:
            return 0
        left = 0
        right = 1  # 利用一前一后两个指针，不断向后循环
        while n:  # 向后循环走n次
            right += left
            left = right - left
            n -= 1
        return left # 注意这里返回的是left，不是right


obj = Solution()
print(obj.Fibonacci(1000)) 

线性解法

def fibonacci(n):
    if n <= 1:
        return (n, 0)
    else:
        (a, b) = fibonacci(n - 1) 
        return (a + b, a)


print(fibonacci(10)) # (55, 34) 

'''
还是用到了递归，在算前100个没问题，算第1000个时，直接爆掉！
'''