8.2 递归

8.2.1 概述

  • 递归：指在当前方法内调用自己的这种现象。
  • 递归的分类:
    • 递归分为两种，直接递归和间接递归。
    • 直接递归称为方法自身调用自己。
    • 间接递归可以A方法调用B方法，B方法调用C方法，C方法调用A方法。
  • 注意事项：
    • 递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。
    • 在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出。
    • 构造方法，禁止递归
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class Demo01DiGui {
    public static void main(String[] args) {
        // a();
        b(1);
    }
    /*
    * 3.构造方法,禁止递归
    * 编译报错:构造方法是创建对象使用的,不能让对象一直创建下去
    */
    public Demo01DiGui() {
        //Demo01DiGui();
    }
    /*
    * 2.在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出。
    * 4993
    * Exception in thread "main" java.lang.StackOverflowError
    */
    private static void b(int i) {
        System.out.println(i);
        //添加一个递归结束的条件,i==5000的时候结束
        if(i==5000){
            return;//结束方法
        }
        b(++i);
    }
    /*
    * 1.递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。 
    * Exception in thread "main" java.lang.StackOverflowError
    */
    private static void a() {
        System.out.println("a方法");
        a();
    }
}

8.2.2 递归累加求和

计算1 ~ n的和

分析：num的累和 = num + (num-1)的累和，所以可以把累和的操作定义成一个方法，递归调用。

实现代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class DiGuiDemo {
    public static void main(String[] args) {
        //计算1~num的和，使用递归完成
        int num = 5;
        // 调用求和的方法
        int sum = getSum(num);
        // 输出结果
        System.out.println(sum);
    }
    /*
    通过递归算法实现.
    参数列表:int
    返回值类型: int
    */
    public static int getSum(int num) {
        /*
        num为1时,方法返回1,
        相当于是方法的出口,num总有是1的情况
        */
        if(num == 1){
            return 1;
        }
        /*
        num不为1时,方法返回 num +(num‐1)的累和
        递归调用getSum方法
        */
        return num + getSum(num‐1);
    }
}

代码执行图解

小贴士：
  递归一定要有条件限定，保证递归能够停止下来，次数不要太多，否则会发生栈内存溢出。

8.2.3 递归求阶乘

  • 阶乘：所有小于及等于该数的正整数的积。 
    1
    n的阶乘：n! = n * (n‐1) *...* 3 * 2 * 1
  • 分析：*这与累加类似,只不过换成了乘法运算，但需要注意阶乘值符合int类型的范围。 
    1
    推理得出：n! = n * (n‐1)!

    代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class DiGuiDemo {
    //计算n的阶乘，使用递归完成
    public static void main(String[] args) {
        int n = 3;
        // 调用求阶乘的方法
        int value = getValue(n);
        // 输出结果
        System.out.println("阶乘为:"+ value);
    }
    /*
    通过递归算法实现.
    参数列表:int
    返回值类型: int
    */
    public static int getValue(int n) {
        // 1的阶乘为1
        if (n == 1) {
            return 1;
        }
    /*
    n不为1时,方法返回 n! = n*(n‐1)!
    递归调用getValue方法
    */
        return n * getValue(n ‐ 1);
    }
}

8.2.4 递归打印多级目录

分析：多级目录的打印，就是当目录的嵌套。遍历之前，无从知道到底有多少级目录，所以我们还是要使用递归实现。

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class DiGuiDemo2 {
    public static void main(String[] args) {
        // 创建File对象
        File dir = new File("D:\\aaa");
        // 调用打印目录方法
        printDir(dir);
    }
    public static void printDir(File dir) {
        // 获取子文件和目录
        File[] files = dir.listFiles();
        // 循环打印
        /*
        判断:
        当是文件时,打印绝对路径.
        当是目录时,继续调用打印目录的方法,形成递归调用.
        */
        for (File file : files) {
            // 判断
            if (file.isFile()) {
                // 是文件,输出文件绝对路径
                System.out.println("文件名:"+ file.getAbsolutePath());
            } else {
                // 是目录,输出目录绝对路径
                System.out.println("目录:"+file.getAbsolutePath());
                // 继续遍历,调用printDir,形成递归
                printDir(file);
            }
        }
    }
}