python中递归的用法_递归方程的求解方法过程

递归剖析

• 递归真的很重要，之前学的时候，学的一知半解，以为真正了解，每次想到递归，就记得一句：返回给函数的调用者，嗯？函数调用者，你是说外部，还是内部啊？疑问太多了，还有就是被告知一句：递归能解决的问题，循环都能解决，所以就更加不重视递归了！直到接触算法后，在解决问题时，最快，最容易理解的解法就是递归，但是此时的递归却是看不太懂为什么要这样做！我先来说下，在算法中遇到可以用递归轻松完成的：希尔排序、归并排序、快速排序、反转链表及各种反转问题、二叉树的深度遍历、二叉树的各种题基本可以用、全排列…还有算法步骤里需要用到，太多了，所以，递归非常重要！“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)

今天的文章python中递归的用法_递归方程的求解方法过程分享到此就结束了，感谢您的阅读。