Java --> 方法递归【猴子吃桃、斐波那契数列、汉诺塔、非规律化递归问题（文件搜索、啤酒问题）】

 递归：方法直接或者间接调用自己的形式

• 递归案例导学：使用递归计算1~n的阶乘；

1. f(n) = 1*2*3*4*5*...*n ；
2. f(n) = f(n-1) * f(n)；

public class RecursionDemo2 {
    public static void main(String[] args) {
        System.out.println(mul(5));
    }
    public static int mul(int n){
        if(n == 1){
            return 1;
        }else {
            return mul(n-1) * n;
        }
    }
}

示例代码运行结果：

•  同理：计算1~n的和方法思路也是类似的，只不过是将上边代码的乘号变成了加号

public class RecursionDemo3 {
    public static void main(String[] args) {
        System.out.println(add(5));
    }
    public static int add(int n){
        if(n == 1){
            return 1;
        }else {
            return add(n-1) + n;
        }
    }
}

示例代码运行结果：

•  递归的经典问题 
• 一、
• 猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，觉得好不过瘾，于是又多吃了一个，第二天又吃了前天剩余桃子数量的一半，觉得好不过瘾，于是又吃了一个，以后每天都是吃前天剩余桃子数量的一半，觉得好不过瘾，又多吃了一个，等到第十天的时候发现桃子只有一个了。问题：请问猴子第一天吃了多少个桃子？

public class MonkeyEatPeach {
    public static void main(String[] args) {
        /**
         * 分析：设天数为n,f(n)为第n天剩余的桃子数
         * n:天数，     f(n):剩余桃子数
         * n = 10 ---> f(n) = 1 = [f(9) - 1] / 2
         * n = 9 ----> f(9) = [f(8) - 1] / 2
         * n = 8 --->  f(8) = [f(7) - 1] / 2
         * ...
         * n = 2 --->  f(2) = [f(1) / 2 ] - 1
         * 得出规律：
         * f(n) = [f(n-1) / 2] - 1
         * 将 n 替换为 n+1:
         * f(n+1) = [f(n) / 2] - 1
         * 得出公式：
         * 2f(n+1) = f(n) - 2;
         */
        System.out.println(f(1));
        for (int i = 10; i >= 1; i--) {
            System.out.println("第" + i + "天剩余桃子数量：" + f(i));
        }
    }
    public static int f(int n){
        if (n == 10){
            return 1;
        }else {
            return 2*f(n + 1) + 2;
        }
    }
}

示例代码运行结果：

•  二、
• 斐波那契数列：
• 斐波那契数列指的是这样一个数列：1，1，2，3，5，8，13，21，34，55，89...，这个数列从第3项开始，每一项都等于前两项之和，则第n项的数为多少？

public class FibonacciDemo {
    public static void main(String[] args) {
        for (int i = 1; i <= 11; i++) {
            System.out.println("第" + i + "项：" + fibonacci(i));
        }
    }
    //1，1，2，3，5，8，13，21，34，55，89...，这个数列从第3项开始，每一项都等于前两项之和
    public static int fibonacci(int n){
        if (n == 1 || n == 2){
            return 1;
        }
        else {
            //化大问题为小问题
            //第n项等与前两项之和
            return fibonacci(n-2) + fibonacci(n-1);
        }
    }
}

示例代码运行结果：

•  三、
• 汉诺塔问题

 

 我们可以先列举出来当盘子数量较少时的移动方案：

• 当A杆有1个盘子时，A -> C
• 当A杆有2个盘子时，A -> B,  A -> C, B -> C
• 当A杆有3个盘子时，A -> C, A -> B, C -> B,A->C, B->A, B->C, A->C 

public class HanoiDemo {
    public static void main(String[] args) {
        hanoi(1,'A','B','C');
        System.out.println();
        hanoi(2,'A','B','C');
        System.out.println();
        hanoi(3,'A','B','C');
    }

    public static void move(char A, char C){
        System.out.print(A + "->" + C + " ");
    }

    /**
     *
     * @param n  盘子数量
     * @param A  盘子的起始位置
     * @param B  盘子的中转位置
     * @param C  盘子的目标位置
     */
    public static void hanoi(int n,char A, char B, char C){
        if (n == 1){
            //只有一个盘子时直接把A柱子上的盘子移动到目的柱子C柱上
            System.out.print(A + "->" + C + " ");
        }
        else {
            //化大为小，相当于将A柱上n-1个盘子经过C中转后放置在B柱上
            hanoi(n-1,A,C,B);
            //将A柱上剩余的那个最大的盘子从A柱移动到C柱
            move(A,C);
            //最后将B柱上的n-1个盘子经A中转后全部放置在C盘上边
            hanoi(n-1,B,A, C);
        }
    }
}

示例代码运行结果：

 可以看到，运行结果与我们之前手动推敲的如出一辙~

 参考B站的视频：我感觉这个是讲的挺清楚的，分享给大家哈~

点击此处跳转到视频地址

• 非规律化递归问题：文件搜索
• 需求：从D盘中，搜索出某个文件名称并输出绝对路径；
• 分析：

1. 先定位出一级文件对象；
2. 遍历全部的一级文件对象，判断是否是文件；
3. 如果是文件，判断是否是自己想要的；
4. 如果是文件夹，需要继续以上3个步骤（递归）。

public class RecursionDemo5 {
    public static void main(String[] args) {
        searchFile(new File("D:/"), "XMind.exe");
    }

    /**
     * @param dir      文件对象，被搜索的文件目录
     * @param fileName 被搜索的文件名
     */
    public static void searchFile(File dir, String fileName) {
        if (dir != null && dir.length() > 0){   //过滤掉空的文件夹和空的文件
            //提取当前目录下的一级文件对象
            File[] files = dir.listFiles();
            if (files != null){
                for (File file : files) {
                    if (file.isFile()){
                        if (file.getName().contains(fileName)){
                            System.out.println(file.getAbsolutePath());
                        }
                    }
                    else {
                        searchFile(file,fileName);
                    }
                }
            }
        }
    }
}

示例代码运行结果：

 

•  啤酒问题：啤酒2元1瓶，4个盖子可以换一瓶，2个空瓶可以换一瓶，请问：10元钱可以和多少瓶啤酒，剩余多少空瓶和盖子？
• 答案：15瓶 3盖子 1瓶子

public class BearDemo {
    public static int totalNumber;
    public static int lastEmptyBottleNumber;
    public static int lastCoverNumber;
    public static void main(String[] args) {
        buyBear(10);
        System.out.println(totalNumber);
        System.out.println(lastEmptyBottleNumber);
        System.out.println(lastCoverNumber);
    }
    public static void buyBear(int money){
        int buyNumber = money / 2;
        totalNumber += buyNumber;
        //计算每一轮此的瓶子数量
        int bottleNumber = lastEmptyBottleNumber + buyNumber;
        //计算每一轮此盖子的数量
        int coverNumber = lastCoverNumber + buyNumber;
        //将瓶子换算成钱
        int allMoney = 0;
        if (bottleNumber >= 2){
            //这么写是为了处理瓶子数量为单数的情况，所以此处不能写为 allMoney += bottleNumber
            allMoney += (bottleNumber / 2) * 2;
        }
        //换算不完的放到 lastEmptyBottleNumber 中
        lastEmptyBottleNumber = bottleNumber % 2;
        //同理，盖子的换算步骤也是类似的
        if (coverNumber >= 4){
            allMoney += (coverNumber / 4) * 2;
        }
        lastCoverNumber = coverNumber % 4;
        //递归的条件为钱数大于2
        if (allMoney >= 2){
            buyBear(allMoney);
        }
    }
}

程序运行结果：