递归函数
描述：
如果一个函数在内部调用自身本身，这个函数就是递归函数
递归函数特性：
（1）必须有一个明确的结束条件
（2）每次进入更深一层递归时，问题规模相比上次递归都应有所减少
（3）相邻两次重复之间有紧密的联系，前一次要为后一次做准备
（4）递归效率不高，递归层次过多会导致溢出
首先，我们可以从字面上来理解递归函数
递：传递出去的意思
归：回来的意思
递归函数就是一个有去有回的过程，以下一个简单的例子来解释递归函数：
实例：
计算一个10以下（包括10）整数的加法运算:
（1）初级写法：
n = 0
for i in range(11):
n += i
print(n)
（2）中级写法：
使用 reduce 高阶函数进行累计运算
from functools import reduce
print(reduce(lambda x, y: x+y, range(11)))
（3）递归函数的写法：
def add(n):
if n == 1:
return n
else:
return n + add(n -1)
print(add(10))
这三种方法，显然第二种是最简单的，但是这里是为了研究递归函数的用法，要了解递归函数的工作流程，就需要分解递归函数。
这里只是为了说明问题，调用 add(5) ：
def add(n): # n = 5
if n == 1:
return n
else:
return n + add(n -1) # 5 + add(5 -1)
def add(n): # add(4)
if n == 1:
return n
else:
return n + add(n -1) # 4 + add(4 -1)
def add(n): # add(3)
if n == 1:
return n
else:
return n + add(n -1) # 3 + add(3 -1)
def add(n): # add(2)
if n == 1:
return n
else:
return n + add(n -1) # 2 + add(2 -1)
def add(n): # add(1)
if n == 1: # n = 1
return n # return 1
else:
return n + add(n -1)
以上是我们通过代码执行流程分解出来的过程信息。
每当函数内部调用自身的时候，外部函数挂起，执行内部函数，当内部函数执行完毕，然后在执行外部函数；
用简单的图形来表示，如下：
===> add(5)
===> 5 + add(4)
===> 5 + (4 + add(3))
===> 5 + (4 + (3 + add(2)))
===> 5 + (4 + (3 + (2 + add(1))))
===> 5 + (4 + (3 + (2 + 1)))
===> 5 + (4 + (3 + 3))
===> 5 + (4 + 6)
===> 5 + 10
===> 15
递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。
实例：
使用递归函数实现一个三级菜单的效果
menu = {
'北京': {
'海淀': {
'五道口': {
'soho': {},
'网易': {},
'google': {}
},
'中关村': {
'爱奇艺': {},
'汽车之家': {},
'youku': {},
},
'上地': {
'百度': {},
},
},
'昌平': {
'沙河': {
'北航': {},
},
'天通苑': {},
'回龙观': {},
},
'朝阳': {},
'东城': {},
},
'上海': {
'闵行': {
"人民广场": {
'炸鸡店': {}
}
},
'闸北': {
'火车战': {
'携程': {}
}
},
'浦东': {},
},
'山东': {},
}
三级菜单
提示：在编写递归函数的时候要牢记以下三点：
（1）必须有一个明确的结束条件
（2）当数据按照一定规律执行的时候，才能考虑递归实现
（3）只有调用自身的函数才是递归函数
def treeML(dic):
while True:
for i in dic:
print(i)
key = input('>>>').strip()
if key == 'q' or key == 'b':
return key
elif key in dic:
res = treeML(dic[key])
if res == 'q':
return 'q'
treeML(menu)
递归函数实现三级菜单
二分查找算法与递归函数
二分查找算法：
简单来讲，就是一半一半的找。
二份查找实例：
有这样一个数列：
1，2，3，4，5
当我们想要查找数字：4
原始的办法：
从数列中一个一个遍历，直到找到 4 为止，查找了 4 次。
二分查找算法：
首先切一半得到：3，因为 3< 4 我们获取右半边的数列 4, 5
然后我们在切一半得到：4，4=4，在二分算法中，我们一共就找了 2 次就得到结果。
当我们想的多了，总结出更加便捷的方式，计算机才能更加高效的工作；
现在通过递归函数来实现，二分查找算法：
数列：
l = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88]
查找序列中是否有数字：83
l = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88]
基础实现：
def find(l, aim):
mid_index = len(l) // 2 # 这里需要取整数不能是小数
if l[mid_index] > aim: # 当取的值大于要找的值，取左边
find(l[:mid_index], aim) # 通过切片取list左边的值
elif l[mid_index] < aim: # 当取的值大于要找的值，取右边
find(l[mid_index+1:], aim) # 通过切片取list右边的值
else:
print(mid_index, l[mid_index]) # 数字比较只有三种情况，大于、小于、等于
find(l, 82)
上面的实例，虽然找到序列中含有 82 但是 索引位置是有问题的。修改如下：
l = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88]
def find(l, aim, start=None, end=None):
start = start if start else 0
end = len(l) -1 if end is None else end
mid_index = (end - start) // 2 + start
if start > end:
return None
if l[mid_index] > aim:
return find(l, aim, start, mid_index-1)
elif l[mid_index] < aim:
return find(l, aim, mid_index+1, end)
elif l[mid_index] == aim:
return mid_index, l[mid_index]
res = find(l, 82)
print(res)
# 执行结果：
# (22, 82)
以上递归函数，比较疑惑的地方：
end = len(l)-1 if end is None else end
这里为什么：len(l)-1
分析结果如下：
提示：如果要对递归函数进行分析，需要将代码执行流程分解开，查看就更加明显了。
l = [2,3,5]
def find(l, aim, start=None, end=None):
start = start if start else 0 # start = 0
end = len(l) if end is None else end # end = 3
mid_index = (end - start) // 2 + start # mid_index = (3-0) // 2 + 0 =1
if start > end:
return None
if l[mid_index] > aim:
return find(l, aim, start, mid_index-1)
elif l[mid_index] < aim: # 3 < 100
return find(l, aim, mid_index+1, end) # find(l, 6, 2, 3)
elif l[mid_index] == aim:
return mid_index, l[mid_index]
--------------------------------------------------------------------------------------------
通过第一步我们获取到：
find(l, 6, start=2, end=3)
l最大的索引为：2
--------------------------------------------------------------------------------------------
def find(l, aim, start=None, end=None): # find(l, 6, 2, 3)
start = start if start else 0 # start = 2
end = len(l) if end is None else end # end = 3
mid_index = (end - start) // 2 + start # mid_index = (3-2) // 2 + 2 =2
if start > end:
return None
if l[mid_index] > aim:
return find(l, aim, start, mid_index-1)
elif l[mid_index] < aim: # 5 < 6
return find(l, aim, mid_index+1, end) # find(l, 6, 3, 3)
elif l[mid_index] == aim:
return mid_index, l[mid_index]
--------------------------------------------------------------------------------------------
通过第二步我们获取到：
find(l, 6, start=3, end=3)
l最大的索引为：2
--------------------------------------------------------------------------------------------
def find(l, aim, start=None, end=None): # find(l, 6, 3, 3)
start = start if start else 0 # start = 3
end = len(l)-1 if end is None else end # end = 3
mid_index = (end - start) // 2 + start # mid_index = (3-3) // 2 + 3 = 3
if start > end:
return None
if l[mid_index] > aim: # l 最大的索引为：2 这里：l[3] 报错啦，因此 end = len(l)-1 if end is None else end
return find(l, aim, start, mid_index-1)
elif l[mid_index] < aim:
return find(l, aim, mid_index+1, end) # find(l, 6, 3, 3)
elif l[mid_index] == aim:
return mid_index, l[mid_index]
附加题：
使用递归函数求斐波拉契数列.
首先斐波拉契数列如下：
1，1，2，3，5，8
规律：从第三位开始，后面的值是前面两个值的和
def fib(n):
if n == 1 or n == 2:
return 1
return fib(n -1) + fib(n -2)
上面的函数是按照斐波拉契数列规律写出来的，思路是没问题的，但是在函数内部调用两次自身函数，这样的效率非常慢。
因此在使用递归函数时，一定要注意在函数内部只能调用一个，否则严重影响执行效率
上面的递归函数修改如下：
count = 0
def fib(n, a=0, b=1):
# 每次递归获取全局变量count = 0
global count
# 在递归函数中，count = 1
count += 1
# 当 1 < n -1 时，进行函数的递归计算
if count < n-1:
return fib(n, b, a+b)
# 当 1 >= n -1 时，n = 2 或者 n =1 返回 a + b = 0 + 1 = 1
elif count >= n -1:
return a+b
f = fib(10)
print(f)
