递归调用

问题：判断字符串A在中所有出现字符串B中（长度大于1）的索引。不得使用字符串方法indexof，substring等 　　 有小伙伴在面试遇到了这个问题，乍一看如果使用使用字符串方法indexof，substring，很简单容易实现，但如果不使用这些方法，怎么样才能实现这个需求呢 　 　 // 思路: 如果不能使用字符串的相应方法，我们可以把字符串转换成数组，使用递归函数不断去比对相应的数组索引，然后把满足条件的索引打印出来，其实很多现在前后端交互处理数据的方法，用的都是递归偏多，千万别小瞧递归！ 话不多说，我们先上解决问题的方法： <script> // 其实很多现在前后端交互处理数据的方法，用的都是递归变多，千万别小瞧递归 // 思路: 不能使用字符串的相应方法，我们可以把字符串转换成数组，首先使用递归不断去比对相应的数组索引 // 随机的字符 var str1 = 'adfacddtgjacbasaclsaacdctacw'; // 条件筛选的字符 var str2 = 'basaclsa'; // 把相应的字符串转换为数组 var arr1 = str1.split(''); var arr2 = str2.split(''); function test (arr) { // 写一个for循环，先把需要筛选的数组arr2第一个索引拿来比对 for(var i = 0; i

如果二叉树每个节点都具有相同的值，那么该二叉树就是 单值 二叉树。 只有给定的树是单值二叉树时，才返回 true ；否则返回 false 。 节点类： # Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = None 示例 1： 输入：[1,1,1,1,1,null,1] 输出：true 示例 2： 输入：[2,2,2,5,2] 输出：false 提示： 给定树的节点数范围是 [1, 100]。 每个节点的值都是整数，范围为 [0, 99] 。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/univalued-binary-tree 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 分析： 　　对于二叉树的题目大部分都是使用递归算法。 　　1.使用递归，将所有的树的节点值添加到一个集合中，集合有自动去重功能，所以，如果最后set的长度大于1，说明有重复的值。返回false，否则返回True。 　　2.使用递归，判断节点值是否和左孩子和右孩子节点值相同，如果相同，则递归调用函数，将值变为左孩子和右孩子的与

一、递归的核心思想就是自己调用自己，一般来说能够用递归解决的问题应满足3个条件： 1.需要解决的问题可以转化为一个或多个子问题来求解，而这些子问题的求解方法与原问题完全相同，只是在数量和规模上不同。 2.递归调用的次数必须是有限的。 3.必须有结束递归的条件来终止递归。 二、何时使用递归？ 1.定义是递归的 有许多数学公式、数列和概念的定义是递归的。比如求n!,Fibonacci数列等。这些问题的求解过程是可以将其递归定义直接转化为对应的递归算法的。 比如求 n! int fun(int n) { if(n==1) { //递归头 return(1); } else { //递归体 return (fun(n-1)*n); } } 2.有些数据结构是递归的 单链表就是一种递归数据结构，其结点类型定义如下： typedef struct LNode { ElemType data; struct LNode *next; }LinkList; 求一个不带头结点的单链表L所有的data域（假设为int类型）之和的递归算法如下： int Sum(LinkList *L) { if (L == NULL) { return 0; } else { return(L->data+sum(L->next)); } } 3.问题的求解方法是递归的 比如汉诺塔问题： 三、递归的不足

递归： 自己调用自己： 递归，指在当前方法内调用自己的这种现象 递归分为两种，直接递归和间接递归。 直接递归称为方法自身调用自己。间接递归可以A方法调用B方法，B方法调用C方法，C方法调用A方法。 public static void main(String[] args) { a(); } //递归 /* 注意事项 *1.必须有出口，否则无意义 * 2.构造方法不能递归 * 3.递归的次数不能过多（内存有限） * */ public static void a(){ a(); } } 注意：递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。 在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出。 public static void main(String[] args) { // 用递归计算1-100的和 int sum=get(100); System.out.println(sum); int con=getn(5); System.out.println(con); } public static int get(int n){ if(n==1){ return 1; } return n+get(n-1); } public static int getn(int a){ if(a==1){ return 1; } return a

递归：方法定义中调用方法本身 如果是方法的嵌套调用 这不是递归 基本思想就是“自己调用自己” 一个使用递归技术的方法将会直接或者间接的调用自己 几个应注意的点： 　　递归一定要有出口否则就是死递归 　　递归的次数不能太多 否则就内存溢出 　　构造方法不能递归使用 例： public class DiGuiDemo { // public DiGuiDemo() { // DiGuiDemo(); // } } 递归求n的阶乘 public class DiGuiDemo { public static void main(String[] args) { int jc = 1; for (int x = 2; x <= 5; x++) { jc *= x; } System.out.println("5的阶乘是：" + jc); System.out.println("5的阶乘是："+jieCheng(5)); } /* * 做递归要写一个方法: * 返回值类型：int * 参数列表：int n * 出口条件: * if(n == 1) {return 1;} * 规律: * if(n != 1) {return n*方法名(n-1);} */ public static int jieCheng(int n){ if(n==1){ return 1; }else { return

全排列算法-递归&字典序实现 全排列： 从n个不同元素中任取m（m≤n）个元素，按照一定的顺序排列起来，叫做从n个不同元素中取出m个元素的一个排列。当m=n时所有的排列情况叫全排列。 例如： 1 、2 、3三个元素的全排列为： {1，2，3}，{1，3，2}，{2，1，3}，{2，3，1}，{3，1，2}，{3，2，1}。 解法1（递归） 如下图：要对1、2、3、4进行排序，第一个位置上的元素有四种可能：1或2或3或4，假如已经确定了第一个元素为4，剩下的第二个位置上可以是1、2、3，很显然这具有递归结构，如果原始要排列的数组顺序为1、2、3、4，现在只要分别交换1、2，1、3，1、4然后对剩下的3个元素进行递归的排列。 package com.xxx; /** * create by ziqiiii */ public class Test { static public void main(String[] args) { int[] a= {1,2,3}; permutation(a,0); } public static void permutation(int a[],int start ) { //如果已经到了数组的最后一个元素，前面的元素已经排好，输出。 if(start == a.length-1){ for(int i = 0;i < a.length; i++)

package com.maiya; import java.util.Arrays; /** * 排序算法--归并排序法 * 归并排序算法通过递归地平分值列，直至所有的子列都只有一个元素，然后按照次序 * 合并这些子列，从而实现对值列的排序。 * 归并排序算法的一般实现策略为：首先将值列分为大致相同的两个部分，然后递归地 * 对各个子列进行递归分解。重复对值列的递归分解过程，直至满足递归地基本条件， * 即值列按照定义的次序分解为多个只包含一个元素的子列。然后，在控制递归调用结 * 构，该算法将两次递归调用中产生的两个有序子列合并为一个有序子列。 * * @param nums 待排序数组 * @return 输出有序数组 * @author WHF */ public class Sort2 { // 归并排序的实现 public static void main(String[] args) { int[] nums = { 14, 7, 10, 5, 9, 1, 21, 3, 6, 15}; Sort2.sort(nums, 0, nums.length-1); System.out.println(Arrays.toString(nums)); } public static int[] sort(int[] nums, int low, int high) { int

目录 Java File类 1. 概述 2. File类的静态成员变量 3. 路径 4. File类的构造方法 4. 常用方法 获取功能的方法 判断功能的方法 创建和删除功能的方法 5. 目录的遍历 6. 递归 概述 练习一：递归累加求和 练习二：递归求阶乘 练习三：递归打印多级目录 7. 综合案例 文件搜索 fileFilter的原理和使用（文件过滤器） 使用lambda表达式优化 Java File类 1. 概述 java.io.File类 文件和目录路径名的抽象表示形式。 java把电脑中的文件和文件夹（目录）封装成为了一个 File 类，我们可以使用File类对文件和文件夹进行操作。 我们可以使用 File 类的方法： 创建一个文件 / 文件夹 删除文件 / 文件夹 获取文件 / 文件夹 判断文件 / 文件夹 是否存在 对文件夹进行遍历 获取文件的大小 File类是一个与操作系统无关的类，任何的操作系统都可以使用这个类中的方法。 重点：记住三个单词 file：文件 directory：文件夹 / 目录 path：路径 2. File类的静态成员变量 static String pathSeparator：与系统有关的路径分隔符，为了方便，它被表示为一个字符串。 static char pathSeparatorChar ：与系统有关的路径分隔符。 static String

递归： 所谓递归，就是既有传递，又有回归，与其说是传递与回归，初学不如理解是一种 “循序递进”与“规律约束”。 为什么这样说，因为递归算法相比较于循环在代码结构方面个人认为更加简洁清晰，清晰易懂，递归注重的是一种有序的规律，所以在每个程序开始之前，我们只要能找到一个使程序循序递进的规律；并且在整个过程都在用此规律进行传递，但是递归算法也有很大的缺点，会造成内存空间不足，从而形成内存溢出；所以针对这种缺点，就会引入“规律约束”，在每一次算法的的开始之前，先对算法进行一个规律约束，而这种约束可以理解为一个“归期”；即到这个归期不得已而为之…… eg:1 计算1+2+3+4+……+100的值。 function fn(n){ if(n==1)return 1; //归期 return n+fn(n-1); //规律 } console.log(fn(100)); eg:2 计算n 和 1/n！的阶乘。 1. n!function fn(n){ if(n==1)return 1; //归期 return n*fn(n-1); //规律 } console.log(fn(5));2. 1/n! function fn(n){ if(n==1)return 1; //归期 return 1/n*fn(n-1); //规律 } console.log(fn(5)); eg:3 斐波拉契数列

fun(n) = f(n-t)+f(n-1); 需要验证下周期性。 其实，递归函数的工作过程就是自己调用自己。有一些问题用递归就很容易解决，简单的你自己都会吃惊。 我们做事情，一般都是从头开始的，而递归却是从末尾开始的。比如上面的函数吧，当n>3时，它显然只能求助于n-1,n-2。而(n-1)>2,(n-2)>2时，它们就求助于：(n-1)-1,(n-1)-2;(n-2)-1,(n-2)-2;然后··············直到（n-k)<3,(n-k-1)<3时，函数Febc终于有了返回值1 了，它再从头开始计算，然后一直算到n 为止。 通过上面的例子，我们知道递归一定要有一个停止的条件，否则递归就不知道停止了。在上面的例子中， if(n<3) return (1); 就是停止的条件。 然而，使用递归的代价是十分巨大的：它会消耗大量的内存！！递归循环时它用的是堆栈，而堆栈的资源是十分有限的。上面的例子你只能用一个很小的n值。如果n=20，即Febc(20)的话，它将调用Febc(n)函数10000多次！！！而上面一个例子用循环也是十分容易写的： /*using turboc2*/ int febc(int); main() { int n; scanf("%d",&n); febc(n); } int febc(int n) { int a[3],i; a[0]=a[1]=a[2