java之递归算法精选

Posted 2022-09-06 磊哥的Java历险记

前言：

一个人的动力归根结底只能来源于自己，靠别人的光照亮你，你终究会面对黑暗；靠自己的光照亮自己，才能不惧黑夜。与其担心未来，不如抓住已知，奋力前行。

我们上一篇聊到了java之正则表达式，这一篇我们聊一下递归算法，针对于以下的概念，都会有实体例子配合着，给大家演示，希望给历险中的你带来一些帮助！！！  

一.介绍

    程序调用自身的编程技巧称为递归（ recursion）。递归做为一种算法在程序设计语言中广泛应用。 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。一般来说，递归需要有边界条件、递归前进段和递归返回段。当边界条件不满足时，递归前进；当边界条件满足时，递归返回。

二.知识点介绍

   1、递归的概念

    2、递归的注意事项

    3、算法案例

4、递归两种方法

5、递归文件子目录

6、精炼练习

三.知识点详解

1、递归的概念

    递归就是“在一个方法内可以再次调用自身”,如下，method方法又调用了method方法。

代码演示：

package com.Test;

public class Test 
    private final static String name = "磊哥的java历险记-@51博客";
        public static void main(String[] args) 
            //调用方法method（）
            method();
        
        private static void method() 
            //自身调用自身方法
            method();
            System.out.println("调用method()");
            System.out.println("============="+name+"=============");
        
    

上面的程序运行后，控制台会一直打印：调用method()；当然，运行不久就会看到JVM抛出“堆栈溢出异常”——它类似于“无限循环”，但它比循环更消耗内存；

    递归方法开始调用后，在内存中会存在多个method方法，每个method方法均会等待它调用的method方法执行完毕，自己才会执行完毕。

package com.Test;

public class Test 
            private final static String name = "磊哥的java历险记-@51博客";
            /*
             *    递归: 方法自己调用自己
             */
            public static void main(String[] args) 
                //调用story（）方法
                story();
                
                static int count = 0;
                public static void story() 
                    count++;
                    System.out.println("从前有座山");
                    System.out.println("山里有个庙");
                    System.out.println("庙里有个老和尚给小和尚讲故事");
                    System.out.println("讲什么呢? ");
                    System.out.println(count);
                    System.out.println("============="+name+"=============");
                    //自身调用story（）
                    story();
                
            

2、递归的注意事项

    递归调用必须要在某个条件下结束，否则就是死递归。

    递归调用的层次不能太多，否则会堆栈溢出。

    构造方法不能递归调用

3、算法案例

    （1）有些问题可以使用“循环”，也可以使用“递归”解决：求5的阶乘：表示为：1 * 2 * 3 * 4 * 5

代码演示（循环）：

package com.Test;

public class Test 
    private final static String name = "磊哥的java历险记-@51博客";

    public static void main(String[] args) 
        int max = 5;
        int num = 1;
        int result = 1;
        // 求5的阶乘
        while (num <= max) 
            result *= num;
            num++;
        
        System.out.println("result = " + result);
        System.out.println("============="+name+"=============");
        
    

代码演示（递归）：

    算法分析：5! = 5 * 4!;

    先求1的阶乘，再求2的阶乘......求5的阶乘；   

package com.Test;

public class Test 
    private final static String name = "磊哥的java历险记-@51博客";

    public static void main(String[] args) 

        System.out.println("递归结果：" + Factorial(5));
    

        //阶乘方法
        public static int Factorial(int num) 
            if (num == 1) 
                return 1;
            
            return num * Factorial(num - 1);
            
        

4、递归两种方法

    递归分为两种，直接递归和间接递归。

    直接递归称为方法自身调用自己。间接递归可以A方法调用B方法，B方法调用C方法，C方法调用A方法。

    （1）递归的代码演示，计算1-n之间的和，使用递归完成

代码演示：

package com.Test;

public class Test 
    private final static String name = "磊哥的java历险记-@51博客";

    public static void main(String[] args) 

                //计算1~num的和，使用递归完成
                int n = 5;
                int sum = getSum(n);
                System.out.println(sum);
                System.out.println("============="+name+"=============");
            
            //计算1~num的和 的方法getSum（）
            public static int getSum(int n)
            
                if(n == 1)
                    return 1;
                
                return n + getSum(n-1);
            
        

（2）代码执行流程图解

    注意：递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。

    在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出。

5、递归打印所有子目录中的文件路径

   编写一个方法用来打印指定目录中的文件路径，并进行方法的调用

   要求：若指定的目录有子目录，那么把子目录中的文件路径也打印出来

    步骤：

    （1）指定要打印的目录File对象

    （2）调用getFileAll()方法

    （3）获取指定目录中的所有File对象

    （4）遍历得到每一个File对象

    （5） 判断当前File 对象是否是目录

    判断结果为true，说明为目录，通过递归，再次调用步骤2的getFileAll()方法

    判断结果为false，说明是文件，打印文件的路径

代码演示：

package com.Test;

import java.io.File;

public class Test 
    private final static String name = "磊哥的java历险记-@51博客";

    public static void main(String[] args) 

                //递归打印所有子目录中的文件路径
                File file = new File("D:\\\\下载文件\\\\火狐文件");
                getFileAll(file);
                System.out.println("============="+name+"=============");
            

            //获取指定目录以及子目录中的所有的文件
            public static void getFileAll(File file) 
                File[] files = file.listFiles();
                //遍历当前目录下的所有文件和文件夹
                for (File f : files) 
                    //判断当前遍历到的是否为目录
                    if(f.isDirectory())
                        //是目录，继续获取这个目录下的所有文件和文件夹
                        getFileAll(f);
                    else
                        //不是目录，说明当前f就是文件，那么就打印出来
                        System.out.println(f);
                    
                
            
        

    斐波那契数列的排列是：0，1，1，2，3，5，8，13，21，34，55，89，144……依次类推下去，你会发现，它后一个数等于前面两个数的和。在这个数列中的数字，就被称为斐波那契数。

6、精炼练习

6.1. 题目

（1）使用递归实现斐波那契数列前10个数字。

代码演示（循环）：

package com.Test;

import java.io.File;

public class Test 
    private final static String name = "磊哥的java历险记-@51博客";
        public static void main(String[] args) 
        //定义第一个加数a，初始值为1；定义第二个加数b，初始值为1；定义两个加数之和为c，初始值为0
            int a = 1;
            int b = 1;
            int c = 0;
            //首先在控制台打印出数列中第一个数和第二个数的值
            System.out.print(a + "\\t" + b + "\\t");
            //建立一个for循环，用于循环输出数列中第三位至第十位的数字
            for (int i = 3; i <= 10; i++) 
                //第三个数即为c，a+b等于c的值
                c = a + b;
                //将第一个加数a赋值为数列中的第二个数b的值
                a = b;
                //将第二个加数b赋值为数列中的第三个数c的值
                b = c;
                //在第二次循环打印时，将打印数列中的第四个数为：b + c = b + (a + b)
                System.out.print(c + "\\t");
                System.out.println("============="+name+"=============");
            
        
    

递归：在一个方法内可以再次调用自身。

阶乘递归，注意：

递归必须得有条件结束，死递归。

递归调用层次不能太多，否则也会堆栈溢出。

构造方法不能递归

代码演示（递归）：

package com.Test;

import java.io.File;

public class Test 
    private final static String name = "磊哥的java历险记-@51博客";

                public static void main(String args[])
                    System.out.println("斐波那契数列第1个数为0");
                    System.out.println("斐波那契数列第2个数为1");
                    FactorialRecursive(1,1,2);
                    System.out.println("============="+name+"=============");
                
                //阶乘递归                public static void FactorialRecursive(int one,int two,int count) 
                    if(count==10) 
                        return;
                    
                    two=one+two;
                    one=two-one;
                    System.out.println("斐波那契数列第"+(count+1)+"个数为:"+two);
                    FactorialRecursive(one,two,count+1);
                
            

结语：

当你珍惜自己的过去，满意自己的现在，乐观自己的未来时，你就站在了生活的最高处;当你明了成功不会造就你，失败不会击垮你，平淡不会淹没你时，你就站在了生命的最高处

我会沿着java基础至中阶，高阶，和后面的实战项目，循序渐进，由浅入深，希望能够帮助看到我文章的兄弟们，特别是初学者！感谢大家持续关注！ ！ ！