python编写递归函数_[ python ] 递归函数

递归函数

描述：

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

递归函数特性：

（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）只有调用自身的函数才是递归函数

deftreeML(dic):whileTrue:for i indic:print(i)

key= input('>>>').strip()if key == 'q' or key == 'b':returnkeyelif key indic:

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)