精华内容
下载资源
问答
  • java方法的递归

    2019-12-01 22:37:25
    java的方法递归小白成长之路(方法递归)原理 版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。 小白成长之路(方法递归递归很好理解,但是实际用起来却很难...

    版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。

    小白的成长之路(方法递归)

    递归很好理解,但是实际用起来却很难。我也是才开始学java,如果下面说的哪里有误请大佬谅解。
    先亮代码吧

    	//下面写的是从1依次累加到指定的数。
    	/**
    	加入给一个3那么就从1开始加到3;
    	1 + 2 + 3 ;
    	**/
    public class index {
        public static void main(String[] args) {
            System.out.print(in(3));
        }
        public static int in(int a){
            int sum = a - 1;
            if (sum == 0 ){
                return 1;
            }
            return a  + in(sum) ;
        }
    
    }
    

    原理

    如果要理解递归的话,还需要理解java中的栈(栈的原理是先进后出)
    我们都知道代码是从上往下执行的,当代码调用了这个方法 。方法就会在栈中添加一层。
    请看下面(先看第一部分,在看第二部分)

    第三次执行in方法 >> 当执行到第三次的时候,因为sum = 0 ;所以第三次返回 1;
    第二次执行in方法 >> return a + in(sum); //这里在次调用in方法。
    第一次执行in方法 >> return a + in(sum); //这里在此调用in方法。注意这里调用了in方法并不是代表这个语句执行完成了。(代码执行的优先级得了解清楚了)
    System.out.print(in(3)); // 当程序执行到这里的时候,会在栈中添加in(3)。
    假如这里是栈底
    看这里请根据源代码一起看; 第一部分

    第三次执行in方法 >> 返回的1
    第二次执行in方法 >> return a + in(sum) 加粗的in(sum)的值是第三次执行in的返回值"1" ;a 的值是2; 然后a + 1 返回给下一层的in(sum);
    第一次执行in方法 >> return a + in(sum) 加粗的in(sum)的值是第二次执行in的返回值"3" ; a 的值是3; 然后a + 3 返回给in(3);
    System.out.print(in(3)); 所以这里输出了6;1+2+3=6
    假如这里是栈底
    第二部分

    注意栈是先进后出的理解这个上面的代码就好理解了,我在这里说的可能简单的。但是意思应该是对的,如果我的理解哪里有误;请CSDN的大佬们及时纠正;
    希望对初学者有帮助

    展开全文
  • Java 方法的递归

    2019-07-17 10:20:38
    Java SE 方法的递归 方法自己调用自己 临界条件: 停止自己调用自己 (递归头) 递归前进段:从自己调用自己到临界条件之间这一段 递归后推段:临界条件之后,把方法的结果返回给调用的上一层 public class Demo01{ ...

    Java SE 方法的递归

    方法自己调用自己

    临界条件: 停止自己调用自己 (递归头)
    递归前进段:从自己调用自己到临界条件之间这一段
    递归后推段:临界条件之后,把方法的结果返回给调用的上一层

    public class Demo01{ 
    	public static void main(String[] args){
            //求某个数阶乘 !  
            //返回值:需要 int    参数:需要参数  int 5! = 5*4*3*2*1=5*4! =5*4*3!
            public static int test(int i){
            	//i=1为临界条件,当i=1时return,结束自己调用自己
                if(i==1){
                    return 1;
                }
                return i*test(i-1);
            }
            //----------------------------------------------------------------
            //使用递归打印几几乘法表  
    		//返回值:不需要  参数:参数int n
            public static void print(int n){
           	 	//n=1为临界条件,当n=1时retrun,结束递归
                if(n==1){
                    System.out.println("1*1=1");
                    return;
                }
                //打印 n之前的内容(假设n=5,即为print(4),实现递归)
                print(n-1);
                //打印第n行的内容   *n
                for(int i=1;i<=n;i++){
                    System.out.print(i+"*"+n+"="+i*n+"\t");
                }
                System.out.println(); //一行内容打印完成后换行
    		}    
    	}
    }
    
    展开全文
  • Java方法的递归调用

    2020-01-26 22:33:25
    Java方法的递归调用 方法的递归调用就是方法自身调用自身。 先看下面的例子: public class Test { //使用 for 循环实现1~n的和 public static int loopSum(int n) { int sum = 0; for (int i = 1; i <= ...

    Java方法的递归调用

    方法的递归调用就是方法自身调用自身。

    先看下面的例子:

    public class Test {
    
      /**
       * 使用 for 循环实现1~n的和
       *
       * @param n 参数
       * @return int
       */
      private static int loopSum(int n) {
        int sum = 0;
        for (int i = 1; i <= n; i++) {
          sum += i;
        }
        return sum;
      }
    
      /**
       * 使用递归实现1~n的和
       *
       * @param n 参数
       * @return int
       */
      private static int recursionSum(int n) {
        if (n == 1) {
          return 1;
        } else {
          return n + recursionSum(n - 1);
        }
      }
    
      /**
       * 使用 for 循环实现1~n的乘积
       *
       * @param n 参数
       * @return int
       */
      private static int loopMultiplyValue(int n) {
        int sum = 1;
        for (int i = 1; i <= n; i++) {
          sum *= i;
        }
        return sum;
      }
    
      /**
       * 使用递归实现1~n的乘积
       *
       * @param n 参数
       * @return int
       */
      private static int recursionMultiplyValue(int n) {
        if (n == 1) {
          return 1;
        } else {
          return n * recursionMultiplyValue(n - 1);
        }
      }
    
      public static void main(String[] args) {
        int result1 = loopSum(100);
        int result2 = recursionSum(100);
        System.out.println("result1= " + result1);
        System.out.println("result2= " + result2);
    
        int result3 = loopMultiplyValue(6);
        int result4 = recursionMultiplyValue(6);
        System.out.println("result3= " + result3);
        System.out.println("result4= " + result4);
      }
      
    }
    

    运行结果:
    方法递归调用运行结果
    递归应用中有个经典的例子就是实现斐波那契数列:

    public class FibonacciDemo {
         
    /**
       * 计算斐波那契数列 一对兔子,第一个月不生,第二个月不生,从第三个月开始生下一对兔子 
       * 生下的那一对兔子,第一个月不生第二个月不生,从第三个月开始生下一对兔子 
       * 问:12个月后 一共有多少对兔子?
       * 示例:1 1 2 3 5 8 13 21 34 55 89 144 
       * 分析可知:从第三个月开始 month = (month - 1) + (month - 2)
       *
       * @param month 参数
       * @return int
       */
      private static int getFibonacci(int month) {
        if (month == 1) {
          return 1;
        }
        if (month == 2) {
          return 1;
        }
        return getFibonacci(month - 1) + getFibonacci(month - 2);
      }
    
      public static void main(String[] args) {
        System.out.println(getFibonacci(12));
      }
    	
    }
    

    运行结果:
    斐波那契数列执行结果
    方法的递归调用适用于方法中运算的主体不变,但运行的方法参数会发生变化的场景。
    注意:

    1. 递归一定要有出口,必须可以让程序可以停下;
    2. 递归次数不能过多;
    3. 构造方法,禁止递归。

    以下程序因为递归没有结束的条件,所以一直压栈,没有弹栈,导致栈内存溢出错误!所以递归必须要有结束条件。

    public class RecursionTest{
    
    	public static void main(String[] args) {
    		method();
    	}
    
    	private static void method() {
    		//java.lang.StackOverflowError
    		method(); 
    	}
    	
    }
    

    运行结果:
    无限递归执行结果

    展开全文
  • 0基础java入门:第二十二节.Java方法的递归 一个方法在方法体内调用本身就叫递归,例如下图,层层嵌套自身就叫递归 方法的递归时形成循环的一种方式。通过return关键字来停止循环。递归适合一些循环重复,但不...

    0基础java入门:第二十二节.Java方法的递归

    一个方法在方法体内调用本身就叫递归,例如下图,层层嵌套自身就叫递归

    方法的递归时形成循环的一种方式。通过return关键字来停止循环。递归适合一些循环重复,但不知道循环次数,在特定情况下停止循环的业务情况。

    比如:现在我们来 书写一个程序 ,用于计算某一个整数变量的 阶乘结果。

    分析一波: 一个数字的结成结果就是 从这个数字 开始向前到1 之间的所有整数 相乘的结果。比如 5的结成结果 就是 5*4*3*2*1 的结果。根据这个规律,x的阶乘结果就是 x*(x-1)*(x-1-1) ... ... 直到 *1 结束。在抽象一下这个思想,也就是 x 的结成结果,就是 x-1的阶乘结果和x相乘。如果x的阶乘结果是1就可以直接返回1了 。

    代码演示:

    public class TestFunction {
    	// 主方法 
    	public static void main (String[] args) {
    		int a = 5;
    		// 调用方法
    		int c = jie(a);
    		// 输出结果
    		System.out.println(a+"的阶乘结果是"+c);
    	}
    	/** 方法 jie */
    	public static int jie(int x) {
    		// 如果x是1 结果是1 直接返回
    		if (x == 1){
    			return 1;
    		}
    		// x不是1 继续调用方法 将 x-1 的值 继续调用这个方法
    		return x * jie(x-1); // 这里注意 --一定在x的前边 先-1 再调用方法
    	}
    }

    运行结果:

    分析一波:这里我们忽略了一些情况,比如0的阶乘结果是1 ,负数是没有阶乘结果的。我们先不用纠结这些业务上的细节,通过这段代码,理解递归方法的使用思想方式就可以。

     

     

    展开全文
  • 栈提到方法的递归调用,需要先说一下栈的存储概念。 栈是一个先进后出的压入(push)和弹出(pop)式数据存储结构。若想获取到栈底的对象,就必须先将这个对象上面的所有的对象全部从栈中移除,否则无法获取栈底的对象...
  • JAVA 方法的递归调用

    2019-08-25 20:54:06
    方法递归调用,即方法自已调用自己 public class new_class{ public static int f(int n){ int result=0; if(n==1 ||n==2){ result=1; }else{ result=f(n-1)+f(n-2) return result; }...
  • 提到方法的递归调用,需要先说一下栈的存储概念。  栈是一个先进后出的压入(push)和弹出(pop)式数据存储结构。若想获取到栈底的对象,就必须先将这个对象上面的所有的对象全部从栈中移除,否则无法获取栈底的对象...
  • java 方法的递归调用

    2017-05-24 13:00:19
    递归调用是一种特殊获调用形式,就是方法自己调自己 2 案例: package Lei; /**  *  * 从1+2+3+。。。。。。。。。。。。。+100  *  */ public class MethodDemo {  public static void main...
  • 栈提到方法的递归调用,需要先说一下栈的存储概念。 栈是一个先进后出的压入(push)和弹出(pop)式数据存储结构。若想获取到栈底的对象,就必须先将这个对象上面的所有的对象全部从栈中移除,否则无法获取栈底的对象...
  • 1+2+3+4+5...+98+99+10考察:方法的递归调用难点:递归调用可以看作的循环,既然时循环就要有结束循环的条件,不然就是个死循环。方法一:用for循环来实现累加求和。难点在于,要定义一个变量"sum"来接收每次相加的...
  • 1、递归的概述 递归:指在当前方法内调用自己这种现象 分类: 直接递归方法 自身调用自己 间接递归:A方法调用B方法,B方法调用C方法,C方法调用A方法
  • class 类名称{  属性  方法 } 声明类需要通过关键字class ...声明一个名为tell打印方法; 通过 Person per=new Person();声明并实例化一个类对象; 通过对象.属性 修改类属性 通过对象.方法 调用类
  • }举例:看如下代码即实现递归调用:/*方法递归*/public classMethodDG {public static voidmain(String[] args) {System.out.println("main begin");doSome();System.out.println("main over...
  • 一、递归的思路一个方法在执行时,调用自身被称为“递归”。递归相当于数学归纳法,有一个起始条件,有一个递推公式。递归可以分为:单路递归和多路递归(如二叉树和斐波那契数列)。二、代码举例1、n阶乘//n阶乘...
  • 其中,递归是java方法中的一种,想必看到这篇文章的朋友在前面已经学习掌握了java方法的相关知识点。下面这篇文章主要来学习一下java方法递归的知识。那么什么是java方法递归递归又该如何实现呢?Java方法递归是指...
  • 展开全部java常用递归e68a84e8a2ad62616964757a686964616f31333361323536代码//Top代表树的的根节点private void showNodeList(Collection topList){for(Node top:topList){//显示顶点System.out.println(top....
  • Java学习-Java方法-递归

    2021-04-12 11:42:11
    利用递归可以简单用程序来解决一些复杂问题,它通常把一个大型复杂问题层层转化为一个与原问题相似规模较小问题来求解,递归策略只需要少量程序就可以描述出解题过程所需要多次重复计算,大大地减少了...
  • 前言在数据结构算法设计中,或者一个方法的具体实现的时候,有一种方法叫做“递归”,这种方法在思想上并不是特别难,但是实现起来还是有一些需要注意的。虽然对于很多递归算法都可以由相应的循环迭代来代替,但是...
  • java方法递归

    2019-11-22 16:18:35
    #方法的调用与定义 一.方法的定义: 定义方法的5个要素是修饰符,返回值类型,方法名,参数列表,方法体。 JAVA语言中方法定义的语法格式如下: <修饰符><返回值类型><方法名>([参数类型参数名],...
  • 请详细讲解这段程序是怎么执行,我理解是先执行main函数里count(1),然后进入count方法,N值为1,所以执行IF语句,直到count(5),此时退出if 循环,打印N=5 ,然后应该没有要执行东西了,可是答案是5 4 3 2 1 ...
  • Java方法递归思想

    2021-03-16 13:30:57
    递归【基于栈】:A方法调用A方法(自己调用自己) 递归结构包括两部分: 1. 递归头:什么时候不调用自身方法。如果没有头,将陷入死循环。 2. 递归体:什么时候需要调用自身方法。 注:适用于计算量小情况 耗时 ...
  • Java方法递归调用

    2021-01-24 21:09:45
    递归就是:A方法调用A方法!就是自己调用自己 利用递归可以用简单地程序来解决一些复杂问题。他通常把一个大型复杂问题层层转化为一个与原问题相似规模较小问题来求解,递归策略只需少量程序就可描述出...
  • Java中实现递归的方法有哪些发布时间:2020-11-10 16:44:28来源:亿速云阅读:58作者:LeahJava中实现递归的方法有哪些?很多新手对此不是很清楚,为了帮助大家解决这个难题,下面小编将为大家详细讲解,有这方面...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,440
精华内容 3,776
关键字:

java方法的递归

java 订阅