递归调用

个人博客文章地址 文章目录 6.1 递归需要遵守的重要规则 6.2 递归-迷宫问题 6.3 递归-八皇后问题(回溯算法) 6.1 递归需要遵守的重要规则 执行一个方法时，就创建一个新的受保护的独立空间(栈空间) 方法的局部变量是独立的，不会相互影响, 比如n变量 如果方法中使用的是引用类型变量(比如数组)，就会共享该引用类型的数据. 递归必须向退出递归的条件逼近，否则就是无限递归,出现StackOverflowError，死龟了:) 当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕。 6.2 递归-迷宫问题 说明: 小球得到的路径，和程序员设置的找路策略有关即：找路的上下左右的顺序相关 再得到小球路径时，可以先使用(下右上左)，再改成(上右下左)，看看路径是不是有变化 测试回溯现象 思考: 如何求出最短路径? 代码实现： public class MiGong { public static void main ( String [ ] args ) { // 先创建一个二维数组，模拟迷宫 // 地图 int [ ] [ ] map = new int [ 8 ] [ 7 ] ; // 使用1 表示墙 // 上下全部置为1 for ( int i = 0 ; i < 7 ; i ++ ) { map

一 .递归 在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数 。 递归函数: 一个会调用自身的函数称为递归函数凡是循环能干的事情 递归都能干方式: 写出临界条件 我这一次和上一次的关系 假设当前函数已经能用 调用自身计算上一次结果 在求出本次的结果 必须有一个明确的结束条件； 每次进入更深一层递归时，问题规模相比上次递归都应有所减少 相邻两次重复之间有紧密的联系，前一次要为后一次做准备（通常前一次的输出就作为后一次的输入）。 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧 。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出 import sys print(sys.setrecursionlimit(1000)) # sys.setrecursionlimit() #设置最大递归层数 print(sys.getrecursionlimit()) #获取最大递归层数 # RecursionError: maximum recursion depth exceeded while calling a Python object 递归的错误 最大的深度 def aa(): print("1111") aa()

1、静态方法与非静态方法 静态方法和非静态方法的区别是： 静态方法有static；非静态方法没有。 如：静态方法： public class students { //静态方法 public static void say(){ System.out.println("学生说话了"); } } 调用静态方法： public static void main(String[] args) { students.say(); } 非静态方法： public class Student { //非静态方法 public void say(){ System.out.println("学生说话了"); } 调用非静态方法： public static void main(String[] args) { //实例化这个类 new //对象类型 对象名=对象值 // Student student=new Student(); student.say(); } 都是非静态方法或静态方法，则方法a可以在直接调用方法b: public void a(){ b(); } public void b(){ } 若a是静态，b不是，则不行： //和类一起加载的 public static void a(){ b(); } //类实例化之后才存在 public void b(){ } 2、形参与实参

递归(递推) 递归就在于反复调用自身函数，但是每次把问题范围缩小，直到缩小到可以直接得到边界数据的结果，然后再在返回的路上求出对应的解。(所以， 递归很适合用来实现分治的思想 ) 递归的逻辑中一般有两个重要概念： 递归边界 递归式 其中递归式是将原问题分解为若干个子问题的手段，而递归边界则是分解的尽头。 经典例子：求解n的阶乘 n! = 1 * 2 * 3 * 4 * ··· * n ，这个式子写成递推式就是 n! = (n-1) * n，于是就把规模为n的问题转换为求解规模为n-1的问题。如果用函数F(n)表示n！，就可以写成F(n)=F(n-1) * n (即递归式)，这样规模就变小了。 那么，如果把F(n)变为F(n-1)，又把F(n-1)变为F(n-2)，这样一直减小规模，什么时候是尽头呢？由于0! = 1，因此不妨以F(n) = 1作为递归边界，即当规模减小至n = 0的时候开始“ 回头 ”。 个人感觉这个“ 回头 ”是一些题中的关键点。 于是，可以有一下代码： # include <iostream> using namespace std ; int J ( int n ) { if ( n == 0 ) return 1 ; //当到达递归边界F(0)时，返回F(0) == 1 else return J ( n - 1 ) * n ; //没有到达递归边界时

Java 递归补充_知识点 执行步骤：首先执行Main方法 —> f(5) —> f(4) —> f(3) —> f(2) —>返回了值给f(3) (返回后才调用f(1))—> f(1) —> 返回了值给f(3) —> f(3)的值为2所以返回给 f(4) ，f(3)返回后f(4)调用f(2)的值，计算f(2)的值，f(2)返回值，返回值为1。f(4)返回后f(5)才会调用f(3)，f(3)调用时调用f(2),f(2)返回1时，f(3)继续调用f(1)，f(1)返回，f(3返回)，f(5)返回，main方法继续执行。 添加了判断的代码(if)，代码的健壮性 来源： CSDN 作者： 丨沫沫然丶 链接： https://blog.csdn.net/weixin_42814000/article/details/104185752

一.匿名函数(lambda) 语法: lambda 参数: 返回值 函数名统一都叫lambda 1.把普通函数转换成匿名函数 def func(n) return n * n ret = func(9) print(ret) 普通 a = lambda n: n * n ret = a(9) print(ret) 匿名 其中a可以认为是函数名,但是在__name__中函数名统一是lambda print(func.__name__) #查看函数名 print(a.__name__) #__name__的值都是<lambda> 查看函数名 def func(a, b) return a + b x = lambda a, b : a+b print(x(a , b)) 两个参数的匿名函数 def func(x, y) return x, y s = lambda x, y :(x, y)#如果不放(),s会被分为两部分 lambda x, y :x和y print(s(250, 38)) 两个返回值的匿名函数 fn = lambda *args :max(args) #匿名函数一定是一行函数 print(fn(1,3,8,56))#56 求最大值 二.sorted() 排序函数 语法:sorted(iterable, key, reverse) key:排序规则. 运行流程:

内置函数 1, lambda 匿名函数 lambda 参数: 返回值 函数名统一都叫lambd # print("你好. 我\\叫周润发") # 对用户是友好的. 非正式的字符串 # # # 正式(官方)的字符串, 面向对象的时候 # print(repr("你好, 我\'叫周润发")) # 程序中内部存储的内容, 这个是给程序员看的 # print("我叫%r" % "周润发") # %r 实际上调用的是repr() # 原样输出 # print(r"马化腾说:\"哈哈哈, \" \n\t") print("你好") # 用户看着舒服 print(repr("你好")) # 真实的字符串表示形式(正式的) __str__() __repr__() # 普通的正常的函数 # def func(n): # return n * n # # # ret = func(9) # # print(ret) # # # # # 匿名函数, 语法: lambda 参数: 返回值 # a = lambda n : n * n # # ret = a(9) # # print(ret) # b = lambda x: x+1 # print(a(5)) # 函数的名字可以认为是a # # print(func.__name__) # 查看函数的名字 # print(a.__name__) # _

匿名函数 lambda() 语法: lambad 参数 : 返回值 1 def func(a,b): 2 return a * b 3 print(func(2,5)) 4 5 a = lambda a ,b : a*b # 将上面的函数用一行代码完成 6 print(a(2,5)) 所有匿名函数的名字都是 lambda 可以赋值其他变量名 ,可以自己认为其他变量名是 函数名 查看函数名: 上面函数名查看 print(func.__name__) print(a.__name__) #用来查看函数名 func <lambda> lambda函数可以返回多个值 a = lambda a,b : (a,b) print(a(2,3)) 结果 (2, 3) 返回多个值接收,必须要用元组 返回的是元组 sorted() 排序函数 语法: sorted(iterable,key, reverse) key 排序规则 运行流程: 把可迭代对象中的每一个元素交给后面key函数来执行,得到一个数字(权重),通过这个数字进行排序　 1 lis = [1,34,3,5,2,6,8,32,45,65,76] 2 a = sorted(lis) # 内置函数提供了一个通用的排序方案 ,sorted() 3 print(a) 4 5 结果 6 [1, 2, 3, 5, 6, 8, 32, 34, 45,

文章目录 一、二分查找法 二分查找法变变种：floor和ceil 二、二分搜索树 实现查找表的比较： 二分搜索树定义 插入元素 查找元素 三、二分搜索树的遍历 二分搜索树的遍历（深度优先遍历） 二分搜索树的层序遍历（广度优先遍历） 四、二分搜索树删除节点 删除最大值，最小值 删除任意节点 附录   二叉搜索树是用来解决查找问题的，在介绍二叉搜索树之前，先学习二分查找法。 一、二分查找法   二分查找法只能对于 有序数列 使用（排序后的数组），在中间找一个元素v如果不是v，这在<v和>v两部分查找，时间复杂度为O(logn),如下图所示： 二分查找代码： // 二分查找法,在有序数组arr中,查找target // 如果找到target,返回相应的索引index // 如果没有找到target,返回-1 template < typename T > int binarySearch ( T arr [ ] , int n , T target ) { // 在arr[l...r]之中查找target int l = 0 , r = n - 1 ; while ( r > l ) { //int mid = (l + r)/2; // 防止极端情况下的整形溢出，使用下面的逻辑求出mid int mid = l + ( r - l ) / 2 ; //如果刚好找到 if ( arr [

3.1 栈的定义及抽象数据类型 栈（stack）是一种特殊的线性表，这种表只能在固定的一端进行插入与删除运算。通常称固定插入、删除的一端为栈顶（top），而另一端称为栈底（bottom）。位于栈顶和栈底的元素分别称为顶元和底元。当表中没有元素时，称为空栈。为了与一般的线性表相区别，通常将栈的插入操作称为入栈，将删除操作称为出栈。 线性表S=（a,b,c,d,e） 将S中的元素按照a、b、c、d、e的顺序依次入栈，则出栈的元素顺序为e、d、c、b、a 可以发现，最先进入栈中的元素a最后才出栈，最后入栈的元素e最先被出栈，因为栈的这一特性，故又将其称为后进先出的线性表（lastinfirstout，简称为LIFO）。 3.2 栈的实现 栈的实现既可以采用顺序存储结构也可以采用链式存储结构。采用顺序存储结构实现的栈称为顺序栈，采用链式存储结构实现的栈称为链栈 3.2.1 顺序栈 栈的初始化操作是指按指定的大小为栈动态分配一片连续的存储区，并将该存储区的首地址同时送给栈顶指针top和栈底指针base，表示栈里没有任何元素，此时的栈为空栈。若base的值为NULL时则表明栈不存在。当插入一个新元素时栈顶指针加1，当删除一个元素时栈顶指针减1。栈顶指针top始终比顶元超前一个位置，因此栈满的条件是top-base=stacksize。图3-3所示为栈顶指针和栈中元素的关系。 值得注意的是