Java中的递归（recursion）方法----简单介绍加演示

博主前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住也分享一下给大家，
👉点击跳转到网站

递归方法简介：

一个方法体内调用它自身，每次调用时传入不同的变量，递归有助于编程者解决复杂的问题，同时可以让代码变得简洁。

1. 方法递归包含了一个隐式循环，它会重复执行某段代码，但是这种执行无需循环控制。
2. 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
3. 执行一个方法时，就创建一个新的受保护的独立空间(栈空间)
4. 方法的局部变量是独立的，不会相互影响, 比如n变量
5. 如果方法中使用的是引用类型变量(比如数组)，就会共享该引用类型的数据.
6. 递归必须向退出递归的条件逼近，否则就是无限递归,出现StackOverflowError，死龟了
7. 当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕。

1.用递归求一个1-100的和

package demo;

public class demo1 {
    public static void main(String[] args) {
        int n=100;
        demo1 demo1 = new demo1();
        int sum = demo1.getSum(n);
        System.out.println("1-100的和为："+sum);
    }

    //递归求和
    private int getSum(int n){  //当n==3时
        if (n==1){
            return 1;
        }else {
            return n+getSum(n-1);  //当n=3时，返回结果为3，n=2时，返回结果为2。n=1时，返回结果为1
        }
    }
}

输出结果

Task :demo1.main()
1-100的和为：5050

2.10的阶乘10！懂得其中的逻辑就行，不用太去深究

package demo;

public class demo2 {

    public static void main(String[] args) {
        int n=10;
        demo2 demo2 = new demo2();
        int aa = demo2.factorial(n);
        System.out.println("10的阶乘为："+aa);
    }

    public int factorial(int n){
        if (n==1){
            return 1;
        }else {
            return n * factorial(n-1);
        }
    }
}

输出结果

Task :demo2.main()
100的阶乘为�?3628800

阶乘具体图解如下：

打印问题：

public class RecursionTest {
    public static void main(String[] args) {
        test(4);
    }

    public static void test(int n) {
        if (n > 2) {
            test(n - 1);
        }
        System.out.println("n=" + n);
    }
}

输出结果如下：

n=2
n=3
n=4

具体图解如下：

递归的练习一

代码如下：

public class RecursionExercise01 {
    public static void main(String[] args) {
        T t = new T();
        int n = 7;
        int res = t.fibonacci(n);
        if (res != -1) {
            System.out.println("当n=" + n + " 对应的斐波那契数= " + res);
        }
    }
}

class T {
    public int fibonacci(int n) {
        if (n >= 1) {
            if (n == 1 || n == 2) {
                return 1;
            } else {
                return fibonacci(n - 1) + fibonacci(n - 2);
            }
        } else {
            System.out.println("要求输入的n>=1 的整数");
            return -1;
        }

    }
}

输出结果如下：

当n=7 对应的斐波那契数= 13

具体分析图解如下：

递归练习二

具体代码如下：

public class Recursion02 {
    public static void main(String[] args) {
        //思路分析：
        //1.day=10 有一个桃子
        //2.day=9  有(day10+1)*2
        //3.day=8 有(day9+1)*2 个桃子
        //4.day=7 有(day8+1)*2 个桃子
        //规律：前一天的桃子=(后一天的桃子+1)*2
        A a = new A();
        int peachNum = a.peach(8);
        if (peachNum != -1) {
            System.out.println(peachNum);
        }
    }
}

class A {
    public int peach(int day) {
        if (day == 10) {
            return 1;
        } else if (day >= 1 && day <= 9) {
            return (peach(day + 1) + 1) * 2;
        } else {
            System.out.println("day在1-10");
            return -1;
        }
    }
}

输出结果如下：

10