目录
递归剖析 递归的两个过程 return 返回值 详解
递归思路二分法和递归尾递归递归练习题
递归剖析
递归真的很重要，之前学的时候，学的一知半解，以为真正了解，每次想到递归，就记得一句：返回给函数的调用者，嗯？函数调用者，你是说外部，还是内部啊？疑问太多了，还有就是被告知一句：递归能解决的问题，循环都能解决，所以就更加不重视递归了！直到接触算法后，在解决问题时，最快，最容易理解的解法就是递归，但是此时的递归却是看不太懂为什么要这样做！我先来说下，在算法中遇到可以用递归轻松完成的：希尔排序、归并排序、快速排序、反转链表及各种反转问题、二叉树的深度遍历、二叉树的各种题基本可以用、全排列…还有算法步骤里需要用到，太多了，所以，递归非常重要！“To iterate is human, to recurse divine 迭代是人，递归是神”，接下来，我也是看了很多算法书和视频，重点来整理下递归！
递归的两个过程
首先“递归”包括两个过程：递“去”的过程，“归”回的过程！先从一个简单的递归函数讲起
def di_gui(n):
print(n, "<===1====>")
if n > 0:
di_gui(n - 1)
print(n, '<===2====>')
di_gui(5) # 外部调用后打印的结果是？
递归的执行过程：首先，递归会执行“去”的过程，只需要满足终止条件，就会一直在函数内，带着更新的参数，调用函数自身，注意：到内部调用函数， 以下面的代码不会被执行，而是暂停阻塞；此时 随着函数每调用一次自身，还没有触发 返回值和到达终止条件，等同于在原来的基础上不断“向下/向内”开辟新的内存空间，记住，每次调用一次函数，就不是处在同一空间（想象下《盗梦空间》里的情景，梦中梦，都是处于不同的空间） 什么时候“递”去的过程结束？记住有两种情况>>> 一是：当前这层空间函数全部执行结束（终止条件），二是：执行到了return 返回值，直接返回； 重点来理解下，首先是一，看上面的列子，例子中没有return，但是不断的调用后，最终还是停止了，因为最后n=0时，di_gi(0)还是去调用，从上往下执行时，遇到if n>0 它被终止了，走不下去了，表明，自己能到达的这层空间已经全部执行完毕；接下来请原地返回吧，返回到哪里？返回到函数的调用者，好我们返回到 di_gui(0)，把“到内部调用函数” 以下的代码全部执行完；执行完，看代码走到末尾，以为走出了最外层函数？注意了，此时它所处的空间并不是最外层哦，因为之前它被调用就在空间里面，所以回到的是 di_gui(1)的这一层空间，现在才是真正的开始“回”，所以继续把di_gui(1)的这一层空间，“到内部调用函数”以下的代码全部执行完，回到di_gui(2)的这一层空间…直到到达最开始 从外部调用，让参数5进入的最外层空间位置，才走出来！表示《盗梦空间》里，柯布醒了！ 回来看下，代码输出的结果：5 4 3 2 1 00 1 2 3 4 5 （ 注意00这两个是在同一层空间哦） 从内存角度（本质）来分析：每调用一次函数，都会单独开辟一份栈帧空间，递归函数就是不停的开辟和释放栈帧空间的过程，具体来理解下：一个普通函数从执行到结束，就是一个开辟空间和释放空间的过程；而递归函数是在调用最外层函数时，先开辟一个最外层空间，每调用一次自身，就会在最外层空间内，再自己开辟本次的空间（所以递归耗内存）（还有一种说法是，不断的本次空间的基础上再开辟空间，等于是不断的嵌套，其实这两种说法本质上是一样的，因为信息都可以做到不共享），空间之间如果不通过参数传递或者用return 返回值，信息是不共享的，如下图↓↓↓
递归的数据共享情况：递归每一层间的数据是独立的，不共享，但是可以通过参数或者返回值来形成共享，参数具体在传入的是“引用类型”（比如列表） 递归 必须要有一个出口，如果没有出口就会重复调用，不断的开辟栈帧空间
# 获取最大递归层数：
import sys
res=sys.getrecursionlimit()
print(res) # 结果：1000
# sys.setrecursionlimit(800) 可以自己设置最大递归层数
解释含有 return 返回值的递归，记住 return的返回流程是：先计算，再返回 ，来看下一段求阶乘的代码：
def jie_cheng(n):
if n <= 1:
return 1
return n * jie_cheng(n - 1)
print(jie_cheng(5))
return 是返回到函数调用者，递归函数和普通函数也是一样的，所以递归最后一层空间走到尽头（一是：指向完毕，二是：遇到return，回顾一下而已）遇到return，就要开始返回了，返回到它的调用者（即是阻塞的位置），直到回到最外层空间如果上面的内容看懂了的话，试着解析下：下面这段代码的执行流程
def get_num(num):
if num > 2:
get_num(num - 1)
print(num)
get_num(4) # 输出结果为：2 3 4
代码变化一下：
def get_num(num):
if num > 2:
get_num(num - 1)
else:
print(num)
get_num(4) # 输出结果为 2
'''
解析一下：加了else后，首先代码区有两个分支，
在num>2时，执行会有递归，当n=4 是开辟一层空间；
n=3时开辟一层空间，此时 get_num(2) 再开辟一个空间，
当它从上往下执行过程中，在他本层空间遇到if num>2 不成立，所以走分支 else，直接打印出来；
此时代码还没结束，回到上一层空间，num=3, num>2 已经进入了if 不会走else，
num=4 也不会走else，所以这两层空间没有值输出！
'''
return 返回值 详解
上面这一大部分，就算是递归入门了，接下来才刚刚开始哦！还要继续讲 return ；先来看下这几段代码：求全排列的一部分递归代码，试着分别写出运行结果，并依次分析原因↓↓↓
# 例1：
def fullpermutation(list):
if list is None:
return None
if len(list) == 1:
return [list]
res = []
pivot = list[0]
remain = fullpermutation(list[1:])
print(remain)
print(fullpermutation([1, 2, 3]))
'''
输出结果为：
[[3]]
None
None
'''
递归只会在两种情况下触发“回”的过程，上述是在最后一层空间是碰到了return，所以给回到它的调用处（阻塞处），因为return会给调用者返回一个值，所以在本层空间，remain接收到了一个值：[[3]]；接着执行下面的代码，即是打印remain，所以输出“[[3]]”，执行完print，等于回到了上一层空间，又到了调用处（阻塞处），那么这层空间还有返回值吗？答案是没有，所以“最后一层空间是碰到了return 给它返回的值 只会给最后一层使用”，所以接下来两层都是打印空！
# 例2：
def fullpermutation(list):
if list is None:
return None
if len(list) == 1:
return [list]
res = []
pivot = list[0]
return fullpermutation(list[1:])
print(fullpermutation([1, 2, 3]))
'''
输出结果为：
[[3]]
'''
这次是，在最后一层返回时，获得了一个返回值 [[3]] ，然后回到上一层时，前面又有return 表示需要把本层的返回值，返回到上层的接收处，重复，直到回到最外层，这个从底层传上来的返回值，一直传到了最外层，所以才打印出来的，只有最后一层，但是每次一层都获得了返回值，和例子1 后面两层没有返回值是不同的哦！
# 例3：
def fullpermutation(list):
if list is None:
return None
if len(list) == 1:
return [list]
res = []
pivot = list[0]
remain = fullpermutation(list[1:])
print(list)
print(fullpermutation([1, 2, 3]))
'''
输出结果为：
[2, 3]
[1, 2, 3]
None
'''
最后一层碰到return，触发会的过程，回到调用处，执行阻塞处下面的代码，打印list，这个list是什么？它就是本层空间 参数的规模（因为代码写的是规模不断变小从[1,2,3]>>>[2,3]>>>[3]）,显然，从最后一层回到上一层，此时规模是[2,3]，所以打印list 就是[2, 3]；接着继续回到上一层，即是最外层，规模是[1,2,3]，所以打印[1, 2, 3]，最后的None是因为最外层函数，没有返回值，所以才打印出None
# 例4：
def fullpermutation(list):
if list is None:
return None
if len(list) == 1:
return [list]
res = []
pivot = list[0]
remain = fullpermutation(list[1:])
return list
print(fullpermutation([1, 2, 3]))
'''
输出结果为：
[1, 2, 3]
'''
依照上面的步骤，触发回的过程，只要没有到达最外层，return list 返回本层的规模（参数规模），那么这个返回值就会给本层的接收者 remain 不可能给最外层的接收者，虽然这里没有打印 remain的值，但是这里的remain和第一个列子中的remain，后面层数是有返回值的哦（下面例子就会体现），本例，返回到最外层时，list的本层规模为 [1,2,3] 最外层接收者接收到，然后打印出来，所以是[1,2,3]
# 例5：
def fullpermutation(list):
if list is None:
return None
if len(list) == 1:
return [list]
res = []
pivot = list[0]
remain = fullpermutation(list[1:])
print(remain)
return list
print(fullpermutation([1, 2, 3]))
'''
输出结果为：
[[3]]
[2, 3]
[1, 2, 3]
'''
看上面的例子，这次我们是打印了 remain，因为返回的过程中，指向阻塞处（调用处）下面的代码，每次return list 即是 在本层返回 当前的参数规模，所以 remain 是能接收本层的返回值的，所以会打印 [[3]] ，[2, 3] ；最后 [1, 2, 3] 是最外层打印的
# 例6：
def fullpermutation(list):
if list is None:
return None
if len(list) == 1:
return [list]
res = []
pivot = list[0]
remain = fullpermutation(list[1:])
print(remain)
print(list)
return list
print(fullpermutation([1, 2, 3]))
'''
输出结果为：
[[3]]
[2, 3]
[2, 3]
[1, 2, 3]
[1, 2, 3]
'''
这个，就是所有的融合；通过上面的代码我们来总结下return的返回值：最后一层遇到的return 需要执行 回的过程，此时的返回值 值会返回给最后的调用处的接收者；然后执行 阻塞处下面的代码时，如果又遇到return 这里的返回值，如果没有到达最外层，都是给本层的接收者！为什么要大费周章的讲这个，是因为我们在写递归时，往往不清楚return 要怎么写，已及它的返回值是什么？接下来就要看下return 如何解决问题的 请用递归完成一个字符串的反转，输入字符串“abcd”，完成翻转成“dcba” 除了递归，我们可以直接用字符串的切片来完成，如下，但是这里是要讲递归的思想，不体现方法优劣！
s="abcd"
print(s[::-1])
想一下递归的思路该怎么做？ 思路一：按照上面的例子，不断的划分子规模，我们选的是划分原字符串的规模，都是往后截取的，比如第一次参数s=“abcd” 我们取参数s[1:] ，不断调用函数，每次传入参数为：‘bcd’ ‘cd’ ‘d’ ，这样最后一层返回d 我们能拿到最后一个值，然后最后一个返回值d 加上 当前规模的第一个值，就完成了反转，具体代码如下：
def str_reverse(s):
if len(s) <= 1: # 递归出口
return s
# last = str_reverse(s[1:])
# return last + s[0]
return str_reverse(s[1:]) + s[0] # 每次返回最后一层的值，加上当前规模的第一个值
思路二：改变下子规模，我们这次不划分原字符串，而是从它的索引下手，传入最后一个元素的索引，不断去递归索引的值，这时，变的是end的值，从 3 到 2 1 0，到0时触发回的过程，返回当前索引的值，即是 a （不断向前取值），这时我们再加上当前层的s，因为没有划分s所以s每一层都是等于‘abcd’的，我们每次取当前end索引指向的字符串的值，等于从前往后遍历字符串 ‘abcd’ ，两部分链接起来，就完成了反转：每次的返回值为 a, ba , cba, dcba,
def reve(str, end):
if end == 0:
return "" + str[0]
last = str[end] + reve(str, end - 1)
return last
s = "abcd"
print(reve(s, len(s) - 1))
两种做法都用到return，而是还有重要的递归思路，下面就来看看递归要用什么思路来解 来试下“反转链表”如何用递归做，首先对于一个单链表，要对它反转，我们的思路依旧可以通过不断向后划分子规模，找到它的最后一个结点，然后从后往前依次改变每个结点的指向，让最初的头结点变成尾结点，让它最后指向None；那么具体步骤是：用递归找到最后一个结点，我们可以通过前一个结点的next区域，不断递归，找到下一个结点，直到当前结点的next是None，说明它就是最后一个结点，这也是我们递归的出口，那么依次让它返回，同时改变指向，就完成了，具体看下面的图解：
class ListNode:
def __init__(self, x):
self.val = x
self.next = None
class Solution:
def ReverseList(self, pHead):
if pHead is None: # 判断传入的头结点是否为空
return None
if pHead.next is None: # 如果只有一个结点，直接返回结点；同时也是递归的出口
return pHead
last_node = self.ReverseList(pHead.next) # last_node永远只接收到了最后一个结点
pHead.next.next = pHead # 后一个结点，指向前一个结点
pHead.next = None # 前一个结点，在不同的层，先指向None，如果到达最外层也会指向None
return last_node # 最后返回最后一个结点，表示反转成功
到达最后一层，触发回的过程，返回 last_node 结点给最后第四层，执行阻塞处下面的代码，因为pHead.next.next 是None，它不用改变也行，直接到 return last_node 把 last_node给第三层用… 第三层获得 last_node ，执行阻塞处下面的代码，改变指向，pHead.next.next 是“5结点”，它的指针指向 pHead，即是上一个结点，然后上一个结点指向None；因为这里并不需要用一个temp 来保存前一个指针信息，表面上是断开链接，会丢掉数据，其实不会丢掉，因为他们不再同一层；可以用temp先保存前一个结点的数，这属于递归的写，在我的文章>>>反转链表多种解法 有提到，这里不细说！ 直到 回到最外层，起初的头结点，自然会指向None，最后返回 last_node即可 这才是 链表反转 递归的详细过程，果然和我开始理解的不一样，当初怎么都无法理解，直到用断点调试，才发现真正的过程，是这样，大家可以用断点调试下，看下代码的具体过程，下面是测试代码：
class ListNode:
def __init__(self, x):
self.val = x
self.next = None
class Solution:
def ReverseList(self, pHead):
if pHead is None:
return None
if pHead.next is None:
return pHead
last_node = self.ReverseList(pHead.next)
print(last_node.val)
pHead.next.next = pHead
pHead.next = None
return last_node
def print_list(self, node): # 打印测试
if node is None:
return None
while node:
print(node.val, end="")
node = node.next
print()
if __name__ == '__main__':
n1 = ListNode(1) # 依次实例5个结点
n2 = ListNode(2)
n3 = ListNode(3)
n4 = ListNode(4)
n5 = ListNode(5)
n1.next = n2 # 依次将结点链接起来，形成一个链表
n2.next = n3
n3.next = n4
n4.next = n5
n5.next = None
obj = Solution()
print(obj.ReverseList(n1).val)
# obj.print_list(n1) # 1 2 3 4 5
# obj.print_list(obj.ReverseList(n1)) # 5 4 3 2 1
递归思路
思想： 1.找到当前这个值与上一个值的关系 2.找到程序的出口 有个明确的结束条件 3.假设当前功能已经完成 每次进入更深一层递归时，问题规模相比上次递归都应有所减少 递归思路： （1）找重复：看哪一部分是 实现函数的变化；每次进入更深一层递归时，问题规模相比上次递归都应有所减少 （2）找变化：变化的量应该作为参数 （3）找边界（出口）：终止条件 递归可以分为： （1）直接量+小规模子问题 （2）多个小规模子问题 （3） “切蛋糕”思维 （4）找递推公式，等价交换公式
二分法和递归
# 二分法一定是在排序好的数据里使用
lst = [33, 22, 44, 55, 66, 88, 77, 99, 101, 238, 345, 456, 567, 678, 789]
n = 76
lst.sort()
left = 0
right = len(lst) - 1
while left <= right: # 条件是 开头<=结尾
middle = (left + right) // 2
if lst[middle] > n: # 每次用对折后，中间的数和 查找对象比较
right = middle - 1
elif lst[middle] < n:
left = middle + 1
elif lst[middle] == n:
print("找到了")
break
else:
print("这个数不在列表中")
# 递归函数来做
lst = [22, 33, 44, 55, 66, 77, 88, 99, 101, 238, 345, 456, 567, 678, 789]
def func(n, left, right):
if left <= right: # 边界
mid = (left + right) // 2
if n > lst[mid]:
left = mid + 1
func(n, left, right) # 递归的入口,目的是再确定一次中间的位置
elif n < lst[mid]:
right = mid - 1
func(n, left, right)
elif n == lst[mid]:
print("找到了")
return # 递归出口
else:
print("没有这个数")
return # 递归的出口
func(66, 0, len(lst) - 1)
# 升级：如果找到了要求的数，请返回它的索引
lst = [22, 33, 44, 55, 66, 77, 88, 99, 101, 238, 345, 456, 567, 678, 789]
def func(n, left, right):
if left <= right: # 边界
mid = (left + right) // 2
if n > lst[mid]:
left = mid + 1
return func(n, left, right) # 每一层都要返回给上一层的调用者
elif n < lst[mid]:
right = mid - 1
return func(n, left, right)
elif n == lst[mid]:
print("找到了")
return mid # 多层函数只会将返回值返回给上一层的调用者
else:
print("没有这个数")
return -1
print(func(66, 0, len(lst) - 1))
尾递归
尾递归（自己调用自己，且非表达式：把值放到参数中算）
>>>求斐波那契数列第n位是几？(尾递归做法)
def feibo(num, res, temp):
#使用尾递归法求解斐波那契数量的第num个数字
if num == 0:
return res
else:
return feibo(num - 1, temp, res + temp)
print(feibo(10,0,1))
# 直接递归 尾递归 与 循环 的对比
import time
def Fib_recursion(num):
'''
直接使用递归法求解斐波那契数量的第num个数字
'''
if num < 2:
return num
return Fib_recursion(num - 1) + Fib_recursion(num - 2)
def Fib_tail_recursion(num, res, temp):
'''
使用尾递归法求解斐波那契数量的第num个数字
'''
if num == 0:
return res
else:
return Fib_tail_recursion(num - 1, temp, res + temp)
def Fib_circle(num):
'''
直接使用循环来求解
'''
a = 0
b = 1
for i in range(1, num):
c = a + b
a = b
b = c
return c
if __name__ == '__main__':
num_list = [5, 10, 20, 30, 40, 50]
for num in num_list:
start_time = time.time()
print(Fib_recursion(num))
end_time = time.time()
print(Fib_tail_recursion(num, 0, 1))
end_time2 = time.time()
print(Fib_circle(num))
end_time3 = time.time()
print('正在求解的斐波那契数字下标为%s' % num)
print('直接递归耗时为 ：', end_time - start_time)
print('尾递归调用耗时为：', end_time2 - end_time)
print('直接使用循环耗时为：', end_time3 - end_time2)
递归练习题
>>>打印f-e的数：
def pri(f, e):
if f > e:
return
else:
print(f)
return pri(f + 1, e)
pri(1, 6)
>>>求一个列表的和：
def sum_lis(li, f): # 如果单独是传入一个列表，它体现不了变化
"""
:param li: 传入一个列表
:param f: 列表起始位置
:return: 列表和
"""
if f == len(li) - 1: # 表示起始位置也是结束位置，即只有一个元素
return li[f]
return li[f] + sum_lis(li, f + 1)
print(sum_lis([1, 2, 3, 4, 5], 0))
# 多引入一个 变化的参数，可以想到第一个元素加上剩下的元素，规模不断变小
# 需求:求 1+2+3+4........100 的和
num = 1
count = 0
while num <= 100:
count += num
num += 1
print(count)
'''
思路：
sum(1) + 2 +3.....100
sum(2) + 3........100
sum(3) + 4........100
...
sum(98)+99+100
sum(99) + 100
sum(100)
sum(100) = sum(99) + 100
sum(99) = sum(98) + 99
sum(98) = sum(97) + 98
.....
sum(2) = sum(1) + 2
sum(1) = 1
'''
# 用递归函数解决
def sum(num):
if num == 1: # 出口
return 1
return num + sum(num - 1) # 一直返回sum(num-1)+num，每次递归调用，有return才能有返回值
print(sum(100))
>>>需求：打印斐波那契数列
def fibo(num): # 参数是表示第n个斐波那契数，函数整体表示获取斐波那契数列中第n个数字的值
if num == 1 or num == 2: # 第一个和第二个都是1
return 1 # 返回1，出口
return fibo(num - 1) + fibo(num - 2) # 规律，后一项加上后两项，就等于斐波那契数列第n个数字的值
if __name__ == '__main__':
list_num = [] # 创建一个空列表，开始
for i in range(1, 21): # 遍历1-20
list_num.append(fibo(i)) # 注意这里开始调用函数，获得一个斐波那契数字，将获取到的值填充到list_num
print(list_num)
# 最佳解法：
def fei_bo(n):
if n <= 1:
return (n, 0)
else:
(a, b) = fei_bo(n - 1)
return (a + b, a)
print(fei_bo(5))
# 这里是线性的解法，不再重复计算前一项已知的数
# 求最大公约数
def maxg(m, n):
if n == 0:
return m
return maxg(n, m % n)
print(maxg(6, 0))
# 最大公约数：
# 如果m%n=0 则n是m的最大公约数；例如4%2=0 则2是最大公约数
# 如果m%n=K 则 n%k=?0 >>> f(m,n)=f(n,m%n)
>>>用递归实现列表排序：
def ins(li, k):
if k == 0:
return
# 对前K个元素进行排序
ins(li, k - 1)
# 把位置K的元素插入到前面的部分
x = li[k]
index = k - 1
while x < li[index]:
li[index + 1] = li[index]
index -= 1
li[index + 1] = x
print(li)
ins([1, 4, 3, 2], 3)
>>>需求：递归实现遍历目录
import os
def get_alldirfile(source_path): # 定义一个函数获取用户输入的路径名下所有目录和文件
if not os.path.exists(source_path): # 判断用户输入的目录是否存在
return # 不存在，直接返回，结束该函数，找到一个出口
list_name = os.listdir(source_path) # lisdir获取所有目录，并全部放到一个列表中
for flie_dirname in list_name: # 遍历下所有的文件目录名
abs_path = os.path.join(source_path, flie_dirname) # 拼接成绝对路径
# 判断下一级是否是目录还是文件，是文件结束，是目录继续深入，直到是文件结束
if os.path.isfile(abs_path): # 是文件
print("file_path:%s" % (abs_path))
# 也可进行复制操作，open(abs_path,"w",encoding="utf-8")
if os.path.isdir(abs_path):
get_alldirfile(abs_path) # 递归函数
if __name__ == '__main__':
path = r"F:\日语\快乐50音"
get_alldirfile(path)
# 优化
import os
def file_get(file_path, n):
list_file = os.listdir(file_path)
for file in list_file:
abs_file = os.path.join(file_path, file)
if os.path.isdir(abs_file):
print("\t" * n, file)
file_get(abs_file, n + 1)
else:
print("\t" * n, file)
file_get("D:\KuGou", 1)
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
