python递归

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

（1）递归就是在过程或函数里调用自身；
（2）在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口。

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

递归的缺点：递归算法解题的运行效率较低。在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。

 

"""非递归方式呈现"""
sum = 0
for obj in range(1,101):
    sum+=obj
print sum

""""1+2+3+...+100"""
def foo(n):
    if n>0:return n+foo(n-1)
    if n<=0:return 0
print foo(100)

"""阶乘"""
def fac(n):
    if n==0 or n==1:
        return 1
    else:
        return n*fac(n-1)
print fac(10)    

　　

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

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

>>> fact(1)

1

>>> fact(5)

120

>>> fact(100)

93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000L

　　

如果我们计算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 

　　

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

使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。可以试试fact(1000)：

def fact_iter(product,count,max):
    if count > max:      ####
        return product   ####
    return fact_iter(product * count, count+1, max) ###

print(fact_iter(1,1,5))  #1*1*2*3*4*5
print(fact_iter(1,2,5))
print(fact_iter(2,3,5))  #2*3*4*5
print(fact_iter(6,4,5))   #6*4*5
print(fact_iter(24,5,5))  #24*5
print(fact_iter(120,6,5))  #120

　　

使用递归函数的优点是逻辑简单清晰，缺点是过深的调用会导致栈溢出。

针对尾递归优化的语言可以通过尾递归防止栈溢出。尾递归事实上和循环是等价的，没有循环语句的编程语言只能通过尾递归实现循环。

Python标准的解释器没有针对尾递归做优化，任何递归函数都存在栈溢出的问题。