Python 递归函数

递归函数

1.什么是递归？

 递归就是自己调用自己，在函数内部，可以调用其他函数，如果一个函数在内部调用自己本身，这个函数就是递归函数。

举个例子，我们来计算阶乘n! = 1 x 2 x 3 x ... x n，用函数fact(n)表示，可以看出：

fact(n)=n!=1×2×3×⋅⋅⋅×(n−1)×n=(n−1)!×n=fact(n−1)×n

所以，fact(n)可以表示为n x fact(n-1)，只有n=1时需要特殊处理。

是，fact(n)用递归的方式写出来就是：

def fact(n):
    if n==1:
        return 1
    return n * fact(n - 1)

上面就是一个递归函数。可以试试：

>>> fact(1)
1
>>> fact(5)
120
>>> fact(100)
93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

如果我们计算fact(5)，可以根据函数定义看到计算过程如下：

===> fact(5)
===> 5 * fact(4)
===> 5 * (4 * fact(3))
===> 5 * (4 * (3 * fact(2)))
===> 5 * (4 * (3 * (2 * fact(1))))
===> 5 * (4 * (3 * (2 * 1)))
===> 5 * (4 * (3 * 2))
===> 5 * (4 * 6)
===> 5 * 24
===> 120

递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

2. 递归函数特性：

必须有一个明确的结束条件；
每次进入更深一层递归时，问题规模相比上次递归都应有所减少
相邻两次重复之间有紧密的联系，前一次要为后一次做准备（通常前一次的输出就作为后一次的输入）。
递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）
先举个简单的例子：计算1到100之间相加之和；通过循环和递归两种方式实现

# 循环方式 
def demo_sum(n): 
    sum = 0 
    for i in range(1,n+1) : 
        sum += i 

        print(sum)

 
# 递归方式 

# 递归方式 
def demo_sum2(n): 
    if n>0: 
       return n +demo_sum2(n-1) 
    else: 
       return 0

结果：

5050
5050

3.递归函数的优点：

定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

4.递归函数的缺点

1. 自己调用自己，容易导致栈内存溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。

2. 运行效率比较低

***使用递归函数需要注意防止栈溢出。

把上面的递归求和函数的参数改成10000就导致栈溢出！

RecursionError: maximum recursion depth exceeded in comparison

5.防止递归调用栈内存溢出的方法:

尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。

 尾递归优化:事实上尾递归和循环的效果是一样的，所以，把循环看成是一种特殊的尾递归函数也是可以的,一般递归

def normal_digui(n):
    if n == 1:
        return 1
    else:
        return n + normal_digui(n-1)

执行：

normal_digui(5)
5 + normal_digui(4)
5 + 4 + normal_digui(3)
5 + 4 + 3 + normal_digui(2)
5 + 4 + 3 + 2 + normal_digui(1)
5 + 4 + 3 + 3
5 + 4 + 6
5 + 10
15

可以看到, 一般递归, 每一级递归都需要调用函数, 会创建新的栈,随着递归深度的增加, 创建的栈越来越多, 造成爆栈:boom:

尾递归: 尾递归基于函数的尾调用, 每一级调用直接返回函数的返回值更新调用栈,而不用创建新的调用栈, 类似迭代的实现, 时间和空间上均优化了一般递归!

def wei_digui(n, total=0):
    if n == 0:
        return total
    else:
        return wei_digui(n-1, total+n)

执行：

wei_digui(5)
wei_digui(4, 5)
wei_digui(3, 9)
wei_digui(2, 12)
wei_digui(1, 14)
wei_digui(0, 15)
15

可以看到, 每一级递归的函数调用变成"线性"的形式.

6.递归函数解决的问题：

递归算法一般用于解决三类问题：
（1）数据的定义是按递归定义的。（比如Fibonacci函数）
（2）问题解法按递归算法实现。（回溯）
（3）数据的结构形式是按递归定义的。（比如树的遍历，图的搜索）等