python的递归 | 易学教程

递归算法是一种直接或者间接的调用自身算法的过程。

特点：

1.递归就是在过程或者函数里调用自身。

2.在使用递归策略时，必须有一个明确的递归条件，称为递归出口。

3.递归算法解题通常显得很简洁，但递归算法解题的效率较低。所以一般不倡导使用递归算法设计程序。

4.在递归调用的过程当中系统的每一层的返回点、局部变量等开辟了栈来存储。递归函数次数过多容易造成栈溢出等。

要求：

递归算法所体现的"重复"一般有三个条件：

1.每次在调用规模上都有所缩小（通常是减半）。

2.相邻两次重复之间有紧密的联系，前一次要为后一次做准备（通常前一次的输出就作为后一次的输入）。

3.在问题的规模极小时必须用直接接触解答而不再进行递归调用，因而每次递归调用都是有条件的（以规模未达到直接解答的大小为条件），无条件的递归调用将会成为死循环而不能正常结束。

简而言之，能用循环写的就别用递归

用循环写费脑子

用递归写费内存

还是费脑子好点

斐波那契数列

循环解法

 1 def Fib(n):
 2     fib = [1,1]
 3     if n == 1:
 4         return [1]
 5     elif n == 2:
 6         return [1, 1]
 7     elif n > 2 :
 8         for i in range(2,n):
 9             fib.append(fib[i-2]+fib[i-1])
10     else:
11         return []
12     return fib
1314 if __name__ == __main__:

15　　 print(Fib(10))

递归解法

 1 def funct(n: int):
 2     if n == 1:
 3         return 1
 4     elif n == 2:
 5         return 1
 6     else:
 7         return funct(n - 1) + funct(n - 2)
 8 
 9 if __name__ == __main__:
10 　　for i in range(1, 50):
11     　　print(funct(i))

哥德巴赫的猜想

任何一个充分大的偶数（大于等于6）总可以表示成两个素数之和

循环解法

 1 def prime(n: int):
 2     list_1 = []
 3     for i in range(2, n+1):
 4         for j in range(2, i):
 5             if i % j == 0:
 6                 break
 7         else:
 8             list_1.append(i)
 9     return list_1
10 
11 
12 def main(n: int):
13     list_1 = prime(n)
14     for i in range(6, n + 1, 2):
15         cond = True
16         for j in list_1:
17             for k in list_1:
18                 if j + k == i:
19                     print('%s = %s + %s' % (i, j, k))
20                     cond = False
21                     break
22             if not cond:
23                 break
24         else:
25             print('fail')
26 
27 if __name__ == __main__:
28 　　main(1000)

递归解法

 1 def is_prime(n: int):
 2     for j in range(2, n):
 3         if n % j == 0:
 4             return False
 5     else:
 6         return True
 7 
 8 
 9 def main(n: int, list_1):
10     for i in range(2, n//2):
11         j = n - i
12         if is_prime(i) and is_prime(j) and n not in list_1:
13             list_1.append(n)
14             print('%d = %d + %d' % (n, i ,j))
15         elif not is_prime(i) and i % 2 == 0:
16             main(i, list_1)
17         elif not is_prime(j) and j % 2 == 0:
18             main(j, list_1)
19 
20 if __name__ == __main__:
21 　　list_1 = []
22 　　main(100, list_1)

单就代码量上来看，递归确实比循环少

但递归可能会导致不可预见的栈溢出

尽量少用吧

参考文献：

http://www.jianshu.com/p/dc6adabd4045

来源：https://www.cnblogs.com/piyantonghong/p/7190517.html

标签

递归