精华内容
下载资源
问答
  • Java递归算法

    2020-12-22 17:40:01
    Java递归算法是基于Java语言实现的递归算法。  递归算法的实质是把问题分解成规模缩小的同类问题的子问题,然后递归调用方法来表示问题的解。递归算法对解决一大类问题很有效,它可以使算法简洁和易于理解。  ...
  • java递归算法

    2013-08-24 18:45:49
    java递归算法,java递归算法,java递归算法
  • Java 递归算法

    千次阅读 2020-01-07 00:29:25
    Java递归:简单说就是函数自身直接或间接调用函数的本身。 二、应用场景: 若:一个功能在被重复使用,并每次使用时,参与运算的结果和上一次调用有关,这时就可以使用递归来解决这个问题。 使用要点: 1,...

    一、概述:

      Java递归:简单说就是函数自身直接或间接调用函数的本身。

    二、应用场景:

       若:一个功能在被重复使用,并每次使用时,参与运算的结果和上一次调用有关,这时就可以使用递归来解决这个问题。

       使用要点:

       1,递归一定明确条件。否则容易栈溢出。 

        2,注意一下递归的次数

    三、示例:

      最简单的递归演示

    public class recursionDemo {
    
    
        public static void main(String[] args) {
            show();
        }
        private static void show() {
            method();
        }
        private static void method() {
            show();
        }
    
    }

    四、实际示例

    我们都知道 6的二进制是110,那么程序是怎么执行的呢?

    代码示例:

     public static void main(String[] args) {
            toBin(6);
        }
    
        private static void toBin(int num) {
            if (num>0){
                //取余
                System.out.println(num%2);
                toBin(num/2);
            }
        }

      

    运行过程:

    2、递归演示二:计算1-5,求和

    public static void main(String[] args) {
            //1-5求和
            int sum = getSum(5);
            System.out.println(sum);
        }
    
        private static int getSum(int num) {
            int x=9;
            if (num==1){
                return 1;
            }
    
            return  num+getSum(num-1);
        }

      

    程序运行图:

    五、递归的缺点

         在使用递归时,一定要考虑递归的次数,负责很容易造成虚拟机 “栈溢出”。

    仍然使用上面的求和代码,只是这次将求和基数变为 90000000,看看结果如何

    public static void main(String[] args) {
            //1-90000000求和
            int sum = getSum(90000000);
            System.out.println(sum);
        }
    
        private static int getSum(int num) {
            int x=9;
            if (num==1){
                return 1;
            }
    
            return  num+getSum(num-1);
        }

    果然就造成了虚拟机栈溢出。

     

     

     

    展开全文
  • 主要介绍了Java递归算法,通过两则示例分析了Java递归算法实现阶乘与求和的具体操作技巧,需要的朋友可以参考下
  • java递归算法实例分析

    2020-08-28 13:54:05
    主要介绍了java递归算法实例分析,具有一定借鉴价值,需要的朋友可以参考下。
  • Java递归算法是基于Java语言实现的递归算法。递归算法对解决一大类问题很有效,它可以使算法简洁和易于理解。接下来通过本文给大家介绍Java递归算法相关知识,感兴趣的朋友一起学习吧
  • 关于java递归算法.pdf

    2021-08-07 15:28:57
    关于java递归算法.pdf
  • 在本篇文章里小编给大家整理了关于java递归算法的实例内容,以及相关知识点总结,需要的朋友们可以学习下。
  • Java递归算法构造JSON树形结构,Java递归算法构造JSON树形结构Java递归算法构造JSON树形结构
  • 主要介绍了Java递归算法遍历部门代码示例,具有一定借鉴价值,需要的朋友可以参考下。
  • 好程序员Java培训分享Java递归算法的使用,1、java递归算法基本思路,Java递归算法是基于Java语言实现的递归算法。递归算法是一种直接或者间接调用自身函数或者方法的算法。递归算法实质是把问题分解成规模缩小的...

    好程序员Java培训分享Java递归算法的使用,1、java递归算法基本思路,Java递归算法是基于Java语言实现的递归算法。递归算法是一种直接或者间接调用自身函数或者方法的算法。递归算法实质是把问题分解成规模缩小的同类问题的子问题,然后递归调用方法表示问题的解。递归往往能给我们带来非常简洁非常直观的代码形式,从而使我们的编码大大简化,然而递归的思维确实跟我们的常规思维相逆的,通常都是从上而下的思维问题,而递归趋势从下往上的进行思维。
      2、java递归算法解决问题的特点
      递归就是方法里调用自身
      在使用递归策略时,必须有一个明确的递归结束条件,称为递归出口
      递归算法代码显得很简洁,但递归算法解题的运行效率较低。所以不提倡用递归设计程序。
      在递归调用的过程中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等,所以一般不提倡用递归算法设计程序。
      在做递归算法的时候,一定把握出口,也就是做递归算法必须要有一个明确的递归结束条件。这一点是非常重要的。其实这个出口就是一个条件,当满足了这个条件的时候我们就不再递归了。
      3、java递归算法代码示例:
      public class Factorial {
      //this is a recursive function
      int fact(int n){
      if (n==1) return 1;
      return fact(n-1)*n;
      }
      }
      public class TestFactorial {
      public static void main(String[] args) {
      // TODO Auto-generated method stub
      Factorial factorial=new Factorial();
      System.out.println(“factorial(5)=”+factorial.fact(5));
      }
      }

    展开全文
  • 本文主要对经典的兔子案例分析,来进一步更好的理解和学习java递归算法,具有很好的参考价值,需要的朋友一起来看下吧
  • Java递归算法练习 使用java实现几个比较简单的递归面试题 写递归算法的时候,可以类比数学归纳法。 将每步先简化 单向链表与递归算法 实现单向链表 Node.java /** * @ClassName Node * @Description TODO * @...

    Java递归算法练习

    使用java实现几个比较简单的递归面试题

    写递归算法的时候,可以类比数学归纳法。

    将每步先简化

    单向链表与递归算法

    实现单向链表

    Node.java

    /**
     * @ClassName Node
     * @Description TODO
     * @Version 1.0
     **/
    public class Node {
        private final Integer vaule;
        private Node nextNode;
    
        public Node(Integer vaule) {
            this.vaule = vaule;
        }
    
        public Integer getVaule() {
            return vaule;
        }
    
        public Node getNextNode() {
            return nextNode;
        }
    
        public void setNextNode(Node nextNode) {
            this.nextNode = nextNode;
        }
    
        public static void printLinkedList(Node node) {
            while (node != null) {
                System.out.print(node.getVaule());
                System.out.print(" ");
                node = node.nextNode;
            }
    
            System.out.println();
        }
    }
    
    

    CreateLinkedList.java

    import java.util.Arrays;
    import java.util.List;
    
    /**
     * @ClassName CreateLinkedList
     * @Description TODO
     * @Version 1.0
     **/
    public class CreateLinkedList {
    
    
        /**
         * 创建一个链表
         * @param data 数据源
         * @return 返回链表的头结点
         */
        public Node createLinkedList(List<Integer> data){
            if (data.isEmpty()) {
                return null;
            }
            // 递归实现
            Node firstNode = new Node(data.get(0));
            Node nextNode = createLinkedList(data.subList(1, data.size()));
            firstNode.setNextNode(nextNode);
            return firstNode;
        }
    
    
        public static void main(String[] args) {
            CreateLinkedList createLinkedList = new CreateLinkedList();
            Node.printLinkedList(createLinkedList.createLinkedList(Arrays.asList(1)));
            Node.printLinkedList(createLinkedList.createLinkedList(Arrays.asList()));
            Node.printLinkedList(createLinkedList.createLinkedList(Arrays.asList(1,2,3,4)));
    
        }
    }
    
    

    反转链表

    import java.util.Arrays;
    
    /**
     * @ClassName LinkedListReverser
     * @Description TODO
     * @Version 1.0
     **/
    public class LinkedListReverser {
    
        public Node reverserLinkedList(Node head){
            // 相当于0的情况
            if (head == null) {
                return null;
            }
            // 一个节点的时候,递归到最后一个节点了
            if (head.getNextNode() == null) {
                return head;
            }
            
            // 递归实现
            Node newHead  = reverserLinkedList(head.getNextNode());
            head.getNextNode().setNextNode(head);
            head.setNextNode(null);
    
            return newHead;
    
        }
    
        public static void main(String[] args) {
            LinkedListReverser reverser = new LinkedListReverser();
    
    
            CreateLinkedList createLinkedList = new CreateLinkedList();
            Node.printLinkedList(reverser.reverserLinkedList(
                    createLinkedList.createLinkedList(Arrays.asList()))
            );
            Node.printLinkedList(reverser.reverserLinkedList(
                    createLinkedList.createLinkedList(Arrays.asList(1,2,3,4)))
            );
            Node.printLinkedList(reverser.reverserLinkedList(
                    createLinkedList.createLinkedList(Arrays.asList(1)))
            );
        }
    }
    

    数字组合

    给定一组数字,指定数目的一组数,列出所有可能

    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    
    /**
     * @ClassName ListGroup
     * @Description TODO
     * @Version 1.0
     **/
    public class ListGroup {
    
        public void listDroup(List<Integer> select,List<Integer> data, int n){
    
            // n个数都已经选好了
            if (n == 0) {
                for (int i=0;i<select.size();i++) {
                    System.out.print(select.get(i));
                    System.out.print(" ");
                }
                System.out.println();
                return;
            }
            if (data.isEmpty()) {
                return;
            }
    
            // 选择第一个元素
            select.add(data.get(0));
            listDroup(select,data.subList(1,data.size()),n-1);
    
            // 不选择第一个元素
            select.remove(select.size()-1);
            listDroup(select,data.subList(1,data.size()),n);
    
    
        }
    
        public static void main(String[] args) {
            ListGroup listGroup = new ListGroup();
            listGroup.listDroup(new ArrayList<>(),Arrays.asList(1,2,3,4,5,6),2);
    
            // 其他边界条件测试省略
        }
    
    }
    
    展开全文
  • 本篇文章介绍了,在Java递归算法的使用分析。需要的朋友参考下
  • Java递归算法分解质因数,并总结要点。

    问题描述

      对任意正整数N分解质因素,并以如下方式显示:N=P(1)×P(2)×...×P(n),其中P(i)为N的质因数。


    算法分析

      用Java递归算法实现:从最小质素2开始遍历N中各数,若能被N整除,则输出该数(显然必为质数),并同时将整除后的商代入递归,直到商为1时退出整个计算过程。


    完整代码

    package javastudy;
    
    import java.util.ArrayList;
    import java.util.Scanner;
    
    public class PrimeFactorizationTest {
    
    	public static void main(String[] args) {
    		
    		try(Scanner input = new Scanner(System.in)){
    			
    			System.out.println("输入正整数N(N>1):");
    			int number = input.nextInt();
    			
    			System.out.printf("分解质因数:\n%d = ", number);
    			test1(number);
    			
    			System.out.printf("\n%d的质因数有:", number);
    			test2(number);
    			
    		}catch (Exception e) {  
    			System.out.println("错误:必须输入正整数!");				//捕捉异常,给出提示
    		}
    	}
    	
    	//分解质因数
    	public static void test1(int num) {
    		for(int i=2; i<=num; i++){
    			if( num % i == 0){
    				System.out.print( i + (num>i ? " × ":"\n") );	//或放入数组备用
    				test1(num/i);									//递归
    				break;											//停止往后计算
    			}
    		}
    	}
    	//列举质因数
    	public static void test2(int num){
    		ArrayList<Integer> arr = new ArrayList<>();
    		for(int i=2; i<=num; i++){
    			if((num%i==0) && isPrime(i)) { arr.add(i); }
    		}
    		for(int j=0; j<arr.size(); j++){
    			System.out.print( arr.get(j) + ( j==arr.size()-1?"\n":", " ) );
    		}
    	}
    	//质数判定
    	private static boolean isPrime(int n) {
    		for(int j=2; j<=Math.sqrt(n); j++)
    			if(n % j == 0) return false; 
    		return true;
    	}
    }
    

    运行结果



    要点小结

    1、递归时,for循环必须从2递增至N,否则无法输出最后一个质因数;

    2、由于是从最小质数2开始依次递增整除N,因此复合要求的除数只能是质数,故无需单独判定除数的类型;

    3、判定一个正整数是否为质数,循环至N^0.5内的最大整数即可;

    4、一旦找到第一个质因数,就可以得出最后的分解结果,所以必须在递归结束时用break或return退出计算;

    5、选择性输出结果时,用三目运算符可简化代码;

    展开全文
  • java递归算法浅谈

    2012-08-10 23:21:31
    简单叙述递归算法java编程中的应用,使用递归的利弊。
  • java递归算法的简单示例

    千次阅读 2016-03-11 18:05:20
    java递归算法的简单示例 今天参加笔试,要求用递归实现1+3+5+7...... 没写出来,蛋疼。。。。下面复习一下,自己尝试着写还是没有写出来。。。。。 没有写出来的关键是自己不知道该如何实现求和、实现出口 递归...
  • 一行代码实现java递归算法的阶乘用递归算法求10! 用递归算法求10! 10! 就是求10的?阶乘的表达式,如何用递归算法来计算呢? 10x9x8x7x6x5x4x3x2x1=? 所谓递归算法,就是自己调用自己的算法;但是自己调用自己...
  • Java递归算法应用

    千次阅读 2016-10-19 08:55:37
    递归: 就是函数自身调用自身。 什么时候用递归呢? 当一个功能被重复使用,而每一次使用该功能时的参数不确定,都由上次的功能元素结果来确定。 简单说: 功能内部又用到该功能,但是传递的参数值不确定。...
  • java递归算法之求两个数的最大公约数改下包名即可运行 改下包名即可运行 package cn.blk5; public class CommonDivisor { /** * @author: LIWEI * @updateTime: 2019-06-24 12:19 * 递归求两个数的...
  • java递归算法(1加到100&换汽水)

    千次阅读 2017-07-28 21:12:00
    java递归算法(1加到100&换汽水)老师上课给了两个题目让我们自己写- 不用循环,1加到100-`public static int sum(int num){ if(num==1){ return 1; } if(num>1){ return num+sum(num-1); }
  • java递归算法实现

    万次阅读 多人点赞 2012-06-27 15:42:00
    所以今天就简单说一下这个递归算法,用java实现一个非常经典的递归实例。 递归算法,其实说白了,就是程序的自身调用。它表现在一段程序中往往会遇到调用自身的那样一种coding策略,这样我们就可以利用大道至简的...
  • java递归算法分析

    2014-03-22 23:27:39
    递归算法分析:就是把复杂的问题分解为若干个相对简单的子问题,一直分解下去,直到子问题有答案为止,也就是说到了递推的出口。 递归算法要注意的两点:  (1) 递归就是在方法里调用自己;   (2) 在使用递归...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 135,644
精华内容 54,257
关键字:

java递归算法

java 订阅