精华内容
下载资源
问答
  • 递归函数

    2019-10-14 21:26:58
    递归函数即自调用函数,在函数内部直接或间接地自己调用自己,即函数的嵌套调用函数本身。 2.递归的条件 须有完成函数任务的语句 —个确定是否能避免递归调用的测试 一个递归调用语句,该递归调用语句的参数...

    递归函数

    1.递归函数

    ​ 什么是递归函数?

    ​ 递归函数即自调用函数,在函数体内部直接或间接地自己调用自己,即函数的嵌套调用是函数本身。

    2.递归的条件

    1. 须有完成函数任务的语句
    2. —个确定是否能避免递归调用的测试
    3. 一个递归调用语句,该递归调用语句的参数应该逐渐逼近不满足条件,以至最后断绝递归
    4. 先测试,后递归调用,在递归函数定义中,必须先测试,后递归调用。也就是说,递归调用是有条件的,满足了条件后,才可以递归。

    3.递归的应用场景

    1. 遍历目录下的所有文件

      import os
      
      def find_file(path):
          # os.listdir() 获取path目录下的所有文件,返回列表类型
          # 遍历path目录下的所有文件
          for path_dir  in os.listdir(path):
              # 生成新的目录
              path_dir_file = os.path.join(path, path_dir)
              # 判断是文件还是文件夹os.path.isfile()
              if not os.path.isfile(path_dir_file):
                  # 不是文件则继续递归遍历
                  find_file(path_dir_file)
              else:
                  # 是文件则打印出文件路径
                  print(path_dir_file)
      
      find_file('C:\\Users\\18449\\Desktop\\学习python\\算法学习\\递归文件夹')
      
    2. 利用递归求阶乘

      # 1.定义一个函数,返回n的阶乘的最后结果,
      # 并打印出如5阶乘"5!=120"的效果(要求使用递归!!)
      
      def factorial(num):
          """递归求阶乘"""
          if num == 1:
              return 1
          return num * factorial(num - 1)
      
      num1 = int(input('请输入到几的阶乘:>>'))
      print(factorial(num1))
      
    3. 利用递归求斐波那契(Fibonacci)数列

      # 4.使用函数求前20个斐波那契数列。
      # 提示:斐波那契数列:1,1,2,3,5,8,13,21...
      # 即: 起始两项均为1,此后的项分别为前两项之和。
      # 使用递归
      def fn(a, b):
          if b > 20:
              return b
          list1.append(b)
          return fn(b, a + b)
      
      list1 = []
      fn(0, 1)
      print(list1)
      
    4. 快速排序

      def  quick_sort(alist, start, end):
          """快速排序"""
          # 递归的退出思想
          if start >= end:
              return
          # 设定起始元素为要寻找位置的基准元素
          mid = alist[start]
          # low为序列左边的由左向右移动的游标
          low = start
          # high为序列右边的由右向左移动的游标
          high = end
          while low < high:
              # 如果low与high未重合,high指向的元素不比基准元素小,则high向左移动
              while low < high and alist[high] >= mid:
                  high -= 1
              # 将high指向的元素放到low的位置上
              alist[low] = alist[high]
              # 如果low与high未重合,low指向的元素比基准元素小,则low向右移动
              while low < high and alist[low] < mid:
                  low += 1
              # 将low指向的元素放到high的位置上
              alist[high] = alist[low]
          # 退出循环后,low与high重合,此时所指位置为基准元素的正确位置
          # 将基准元素放到该位置
          alist[low] = mid
          # 对基准元素左边的子序列进行快速排序
          quick_sort(alist, start, low - 1)
          # 对基准元素右边的子序列进行快速排序
          quick_sort(alist, low + 1, end)
      if __name__ == '__main__':
          alist = [54,26,93,17,77,31,44,55,20]
          quick_sort(alist,0,len(alist)-1)
          print(alist)
      
    5. 归并排序

      def merge_sort(alist):
          """归并排序"""
          if len(alist) <= 1:
              return alist
          # 二分分解
          num = len(alist) // 2
          # 使用递归
          left = merge_sort(alist[:num])
          right = merge_sort(alist[num:])
          # 合并
          return merge(left, right)
      
      def merge(left, right):
          '''合并操作,将两个有序数组left[]和right[]合并成一个大的有序数组'''
          #left与right的下标指针
          l, r = 0, 0
          result = []
          while l < len(left) and r < len(right):
              if left[l] <= right[r]:
                  result.append(left[l])
                  l += 1
              else:
                  result.append(right[r])
                  r += 1
          result += left[l:]
          result += right[r:]
          return result
      if __name__ == '__main__':
          alist = [54,26,93,17,77,31,44,55,20]
          sorted_alist = merge_sort(alist)
          print(sorted_alist)
      
    6. 汉诺塔

      # 柱上的盘子个数,b也就是b柱
      # b柱就是一个a移动到c的缓冲区.然后c就是目标柱子
      def han(n, a, b, c):
          if(n == 1):
              print(a,"->",c)
              return
          han(n-1, a, c, b)
          han(1, a, b, c)
          han(n-1, b, a, c)
      
      han(3, "a", "b", "c")
      

      总结:

      ​ 对于阶乘和斐波那契数列这样的问题实际上并不适合使用递归,首先它需要回推会导致计算量大大增加,其次这种问题使用循环本身很容易解决,而且代码也并不复杂。而对于快速排序这种“分而治之”的情况,并不存在回推的过程使用递归可以简化代码增强代码的可读性,对于汉诺塔使用递规不仅大大简化了代码也更易理解。总而言之,不管使用什么方法,其目的无非就是提高程序运行效率,减化代码增强代码的可读性。

    4.递归的评价

    ​ 递归的目的是简化程序设计,使程序易读。但递归增加了系统开销。 时间上, 执行调用与返回的额外工作要占用CPU时间。空间上,随着每递归一次,栈内存就多占用一截。相应的非递归函数虽然效率高,但却比较难编程,而且相对来说可读性差。现代程序设计的目标主要是可读性好。随着计算机硬件性能的不断提高,程序在更多的场合优先考虑可读而不是高效,所以,鼓励用递归函数实现程序思想。

    5.python的递归层数

    ​ python最大递归层数为999层,为了防止无线递归导致堆栈溢出和系统崩溃

    ​ python通过setrecursionlimit函数来设置最大递归数,不过使用时需要小心,过大的递归层数是会导致系统崩溃的,当然也可以通过getrecursionlimit函数获取当前的递归层数。

    展开全文
  • 递归函数的是:自己调用自己函数,在函数内部直接或间接自己调用自己。递归类似于大家中学数学学习过“数学归纳法”。每个递归函数必须包含两个部分: 1.终止条件 表示递归什么时候结束。一般用于返回值,...

    python中的递归函数和嵌套函数

    递归函数

    递归函数指的是:自己调用自己的函数,在函数体内部直接或间接的自己调用自己。递归类似于大家中学数学学习过的“数学归纳法”。每个递归函数必须包含两个部分:

    1.终止条件
    表示递归什么时候结束。一般用于返回值,不再调用自己。
    2.递归步骤
    把第n步的值和第n-1步相关联。
    递归函数由于会创建大量的函数对象、过量的消耗内存和运算能力。在处理大量数据时,谨慎使用。

    def test01(n):
        print("test01:",n)
        if n==0:
            print("over")
        else:
            test01(n-1)
    
        print("test01***",n)
    
    def test02():
        print("test02")
    
    test01(4)
    

    执行结果

    test01: 4
    test01: 3
    test01: 2
    test01: 1
    test01: 0
    over
    test01*** 0
    test01*** 1
    test01*** 2
    test01*** 3
    test01*** 4
    

    嵌套函数

    嵌套函数:在函数内部定义的函数!

    def outer():
        print("outer running")
    
        def inner01():
            print("inner01 running")
    
        inner01()
    
    outer()
    

    执行结果

    outer running
    inner01 running
    

    一般在什么情况下使用嵌套函数?

    1.封装-数据隐藏
    外部无法访问“嵌套函数”。
    2.贯彻DRY(Don’tRepeatYourself)原则
    嵌套函数,可以让我们在函数内部避免重复代码。
    3.闭包

    #使用嵌套函数避免重复代码
    def printChineseName(name,familyName):
        print("{0} {1}".format(familyName,name))
    
    def printEnglishName(name,familyName):
        print("{0} {1}".format(name, familyName))
    
    def printName(isChinese,name,familyName):
        def inner_print(a,b):
            print("{0} {1}".format(a,b))
    
        if isChinese:
            inner_print(familyName,name)
        else:
            inner_print(name,familyName)
    
    printName(True,"小七","高")
    printName(False,"Ivanka","Trump")
    

    执行结果

    高 小七
    Ivanka Trump
    
    展开全文
  • 递归函数的理解

    2016-12-30 19:59:30
    1、什么是递归函数 递归函数就是自调用函数,在函数内部直接或者间接地自己调用自己 Eg:下面程序求n!: double Recur(int i) { double sum; if(i == 1) { sum = 1; } else { sum = i * Recur(i - 1); //计算...

    1、什么是递归函数

    递归函数就是自调用函数,在函数体内部直接或者间接地自己调用自己

    Eg:下面的程序是求n!:

    double Recur(int i)
    {
    double sum;
    if(i == 1)
    {
    sum = 1;
    }
    else
    {
    sum = i * Recur(i - 1);     //计算i的阶层
    }
    return sum;
    }


    2、函数调用机制的说明

    任何函数之间不能嵌套定义, 调用函数与被调用函数之间相互独立(彼此可以调用)。 发生函数调用时,被调函数中保护了调用函数的运行环境和返回地址,使得调用函数的状态可以在被调函数运行返回后完全恢复,而且该状态与被调函数无关。   
    被调函数运行的代码虽是同一个函数的代码体,但由于调用点,调用时状态, 返回点的不同,可以看作是函数的一个副本,与调用函数的代码无关,所以函数的代码是独立的。被调函数运行的栈空间独立于调用函数的栈空间,所以与调用函数之间的数据也是无关的。函数之间靠参数传递和返回值来联系,函数看作为黑盒。   
    这种机制决定了C/C++允许函数递归调用。


    3、递归调用的形式

    递归调用有直接递归调用和间接递归调用两种形式。   
        直接递归即在函数中出现调用函数本身。   
        例如,下面的代码求斐波那契数列第n项。 斐波那契数列的第一和第二项是1,后面每一项是前二项之和,即1,1,2,3,5,8,13,...。 代码中采用直接递归调用:   
          long fib(int x)   
          {   
           if(x>2)   
            return(fib(x-1)+fib(x-2)); //直接递归   
           else   
            return 1;   
          }   
        间接递归调用是指函数中调用了其他函数,而该其他函数却又调用了本函数。例如,下面的代码定义两个函数,它们构成了间接递归调用:   
          int fnl(int a)   
          {

    int b;   
           b=fn2(a+1); //间接递归   
                 //...   
          }   
          int fn2(int s)   
          {   
           int c;   
           c=fnl(s-1); //间接递归   
                 //...   
          }   
        上例中,fn1()函数调用了fn2()函数,而fn2()函数又调用了fn1()函数。


    4、递归的条件

    (1)须有完成函数任务的语句。   
        例如,下面的代码定义了一个递归函数:   
          #include   
        
          void count(int val) //递归函数可以没有返回值   
          { if(val>1)   
             count(val-1); 、   
           cout<<"ok:" <<<="" 此语句完成函数任务="" />   
        该函数的任务是在输出设备上显示"ok:整数值”。   
        (2)—个确定是否能避免递归调用的测试   
        例如,上例的代码中,语句"if(val>1)"便是—个测试, 如果不满足条件,就不进行递归调用。   
        (3)一个递归调用语句。   
      该递归调用语句的参数应该逐渐逼近不满足条件,以至最后断绝递归。   
        例如,上面的代码中,语句“if(val>1)” 便是一个递归调用,参数在渐渐变小,这种发展趋势能使测试"if(val>1)”最终不满足。   
        (4)先测试,后递归调用。   
      在递归函数定义中,必须先测试,后递归调用。也就是说,递归调用是有条件的,满足了条件后,才可以递归。  
        例如,下面的代码无条件调用函数自己,造成无限制递归,终将使栈空间溢出:   
          #include   
          void count(int val)   
          {   
           count(val-1); //无限制递归   
           if(val>1) //该语句无法到达   
            cout <<"ok: " <<    }


    5、消去递归

    大多数递归函数都能用非递归函数来代替。例如,下面的代码求两个整数a,b的最大公约数,用递归和非递归函数分别定义之:   
          long gcdt(int a,int b) //递归版   
          {   
           if(a%b==0)   
            return b;   
           return gcdl(b,a%b);   
          }   
          long gcd2(int a,int b) //非递归版   
          {   
            int temp;   
            while(b!=0)   
            {   
             temp=a%b;   
             a=b;   
             b=temp;   
            }   
            return a;

    }


    6、递归的评价

    递归的目的是简化程序设计,使程序易读。   
        但递归增加了系统开销。 时间上, 执行调用与返回的额外工作要占用CPU时间。空间上,随着每递归一次,栈内存就多占用一截。   
        相应的非递归函数虽然效率高,但却比较难编程,而且相对来说可读性差。   
        现代程序设计的目标主要是可读性好。随着计算机硬件性能的不断提高,程序在更多的场合优先考虑可读而不是高效,所以,鼓励用递归函数实现程序思想。












    展开全文
  • 递归函数、嵌套函数

    2019-03-09 20:28:52
    递归函数的是:自己调用自己函数,在函数内部直接或间接自己调用自己。递归类 似于数学“数学归纳法”。 每个递归函数必须包含两个部分: 1. 终止条件 表示递归什么时候结束。一般用于返回值,不再调用...

    递归函数

    递归函数指的是:自己调用自己的函数,在函数体内部直接或间接的自己调用自己。递归类
    似于数学的“数学归纳法”。 每个递归函数必须包含两个部分:
    1. 终止条件
    表示递归什么时候结束。一般用于返回值,不再调用自己。
    2. 递归步骤
    把第 n 步的值和第 n-1 步相关联。

    递归函数由于会创建大量的函数对象、过量的消耗内存和运算能力。在处理大量数据时,谨
    慎使用。
    【操作】 使用递归函数计算阶乘(factorial)

    factorial(n):
        if n == 1:
            return 1
        return n*factorial(n-1)
    
    for i in range(1,6):
        print("{0}!={1}".format(i,factorial(i)))
        
    执行结果:
    1!=1
    2!=2
    3!=6
    4!=24
    5!=120
    

    嵌套函数(内部函数)

    嵌套函数: 在函数内部定义的函数!
    【操作】 嵌套函数定义

    def f1():
        print('f1 running...')
    
        def f2():
            print('f2 running...')
        f2()
    f1()
    
    执行结果:
    f1 running... 
    f2 running... 
    

    上面程序中,f2()就是定义在 f1 函数内部的函数。f2()的定义和调用都在 f1()函数内部。

    一般在什么情况下使用嵌套函数

    1. 封装 - 数据隐藏
      外部无法访问“嵌套函数”。
    2. 贯彻 DRY(Don’t Repeat Yourself) 原则
      嵌套函数,可以让我们在函数内部避免重复代码。
    3. 闭包

    【操作】使用嵌套函数避免重复代码

    def printChineseName(name,familyName):
        print("{0} {1}".format(familyName,name))
    def printEnglishName(name,familyName):
        print("{0} {1}".format(name, familyName))
    
    #使用 1 个函数代替上面的两个函数
    def printName(isChinese,name,familyName):
        def inner_print(a,b):
            print("{0} {1}".format(a,b))
        if isChinese:
            inner_print(familyName,name)
        else:
            inner_print(name,familyName)
    printName(True,"狐冲","令")
    printName(False,"David","Copperfield")
    
    运行结果:
    令 狐冲
    David  Copperfield
    
    展开全文
  • 编写递归函数来求分段函数的

    千次阅读 2020-03-10 21:40:00
    递归函数即自调用函数,在函数内部直接或间接地自己调用自己,即函数的嵌套调用函数本身。 函数调用机制的说明 任何函数之间不能嵌套定义, 调用函数与被调用函数之间相互独立(彼此可以调用)。 发生函数调用时,...
  • 68_递归函数

    2020-08-28 15:14:31
    递归函数的是:自己调用自己函数,在函数内部直接或间接自己调用自己。递归类 似于大家中学数学学习过“数学归纳法”。 每个递归函数必须包含两个部分: 终止条件 表示递归什么时候结束。一般用于返回值...
  • 递归函数理解

    2014-01-10 10:46:04
    原文:递归函数理解 ... 递归函数即自调用函数,在函数内部直接或间接地自己调用自己,即函数的嵌套调用函数本身。   例如,下面的程序为求n!:   long fact(int n)   {   if(n==1)   re
  • C语言递归函数讲解

    2017-07-03 16:31:00
    递归函数是什么? 是函数、、、、、、、、、、、、、、、、、、、、 你可以把它理解成是for循环与死循环的结合的函数。简单的说:递归函数是有条件终止的死循环函数;... if(n==0) //终止递归函数的循环  ...
  • 递归函数的是:自己调用自己函数,在函数内部直接或间接地自己调用自己。递归类似于大家中学数学学习过“数学归纳法”。 每个递归函数必须包含两个部分: 终止条件 表示递归什么时候结束。一般用于返回值,...
  • 递归函数的是:自己调用自己函数,在函数内部直接或间接自己调用自己。递归类似于大家中学数学学习过“数学归纳法”。 每个递归函数必须包含两个部分: 终止条件 表示递归什么时候结束。一般用于返回值...
  • Shell脚本中递归函数的使用 递归函数: 递归函数就是在函数中自己会调用自己的函数。递归函数中最重要的就是退出条件,建议写递归函数的时候首先设置退出条件。 递归:自已调用自己。 本质: 1、when从什么时候...
  • 一、递归函数 (自己调用自己) 案例1:写了一个fn函数,函数内部再return(返回)fn函数 分析: 口诀:正执行 反推 因此,结果为1+2+3+4+5=15。 案例2:阶层-递归函数 分析: 因此,结果为123=6。 二、闭包 1》什么...
  • 1. 什么是返回值 返回值函数里面传递到到函数外面数据 怎么返回数据 返回值就是return 关键字后面表达式 语法: return 表达式1,表达式2,。。。 说明: return – 关键字,只能在函数体中 ​ 将数据...
  • 1什么是递归函数recursive ...什么是递归函数(recursive function) 递归函数即自调用函数,在函数内部直接或间接地自己调用自己,即函数的嵌套调用函数本身。 例如,下面的程序为求n!: long fact(int n) {
  • 如果在一个函数的函数调用了该函数本身, 这个函数就称为递归函数 递归的组成部分 递归调用与递归终止条件 递归的调用过程 每递归调用一次函数, 都会在栈内存分配一个栈帧 每执行完一次函数, 都会释放相应的...
  • C++递归函数之谈

    2016-10-06 21:57:26
     递归函数即自调用函数,在函数内部直接或间接地自己调用自己,即函数的嵌套调用函数本身。   例如,下面的程序为求n!:   long fact(int n)   {   if(n==1)   return 1;   
  • 递归函数的是:自己调用自己函数,在函数内部直接或间接自己调用自己。递归类似于大家中学数学学习过“数学归纳法”。 每个递归函数必须包含两个部分:1.终止条件 表示递归什么时候结束。一般用于返回值,...
  • 1.什么是返回值 """ 返回值函数里面传递到函数外面数据 1) 怎么返回数据 返回值就是 return 关键字后面表达式值 语法: return 表达式1,表达式2,.... 说明: return - 关键字,只能出现在函数体中 a.将...
  • C语言之递归函数

    2016-08-02 17:17:53
    函数的定义,结构。 y=f(x);→数学函数  定义:返回值,函数名,参数列表,函数 4种形式:  (1)无返回值无参数  (2)无返回值有参数  (3)有返回值无参数  (4)有返回值有参数 2、形参和实参; 形参...
  • - 递归函数即自调函数,在函数内部直接或间接调用自己 -2. 递归理解 - 举例说明:阶乘计算 def factorial(n): if n <= 1: return 1 return n * factorial(n - 1)如何来验证函数是否正确,Paul ...
  • 文章目录尾递归测试尾递归将receive()函数放在最后调用函数前加个return ...尾递归函数的特点在回归过程中不用做任何操作,这个特性很重要,因为大多数现代的编译器会利用这种特点自动生成优化的代码。 参考文章...
  • 2.1什么是递归 1.递归的定义 递归:在函数的定义中又调用函数自身的方法。 尾递归:递归调用函数在...递归模型=递归出口(什么时候结束)+递归体(递推关系) 递归出口 递归体 总结: 每递归调用一次,就需进栈一次
  • 递归 ...(2)递归模式:大问题如何分解为小问题,也称为递归体递归函数只有具备了这两个要素,才能在有限次计算后得出结果 。 可折叠树形菜单 类似于: 代码: 父组件中: <templa..

空空如也

空空如也

1 2 3 4 5 ... 14
收藏数 262
精华内容 104
关键字:

递归函数的递归体是什么