35 递归

• 递归的介绍
  • 以编程的角度来看，递归指的是方法定义中调用方法本身的现象
  • 把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解
  • 递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算

简单的说: 递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂的问题,同时可以让代码变得简洁。

//输出什么?
public static void test(int n) {
    
    
if (n > 2) {
    
    
	test(n - 1);
}
System.out.println("n=" + n);
}

解析：

递归需要遵守的重要规则

1. 执行一个方法时，就创建一个新的受保护的独立空间(栈空间)

2. 方法的局部变量是独立的，不会相互影响, 比如n变量

3. 如果方法中使用的是引用类型变量(比如数组)，就会共享该引用类型的数据.

4. 递归必须向退出递归的条件逼近，否则就是无限递归,出现StackOverflowError，死龟了:)

5. 当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕。

public class DiGuiDemo {
    
    
    public static void main(String[] args) {
    
    
        //回顾不死神兔问题，求第20个月兔子的对数
        //每个月的兔子对数：1,1,2,3,5,8，...
        int[] arr = new int[20];

        arr[0] = 1;
        arr[1] = 1;

        for (int i = 2; i < arr.length; i++) {
    
    
            arr[i] = arr[i - 1] + arr[i - 2];
        }
        System.out.println(arr[19]);
        System.out.println(f(20));
    }

    /*
        递归解决问题，首先就是要定义一个方法：
            定义一个方法f(n)：表示第n个月的兔子对数
            那么，第n-1个月的兔子对数该如何表示呢？f(n-1)
            同理，第n-2个月的兔子对数该如何表示呢？f(n-2)

        StackOverflowError:当堆栈溢出发生时抛出一个应用程序递归太深
     */
    public static int f(int n) {
    
    
        if(n==1 || n==2) {
    
    
            return 1;
        } else {
    
    
            return f(n - 1) + f(n - 2);
        }
    }
}

案例：递归求阶乘

用递归求5的阶乘，并把结果在控制台输出

/*
    需求：
        用递归求5的阶乘，并把结果在控制台输出

    思路：
        1:定义一个方法，用于递归求阶乘，参数为一个int类型的变量
        2:在方法内部判断该变量的值是否是1
            是：返回1
            不是：返回n*(n-1)!
        3:调用方法
        4:输出结果
 */
public class DiGuiDemo01 {
    
    
    public static void main(String[] args) {
    
    
        //调用方法
        int result = jc(5);
        //输出结果
        System.out.println("5的阶乘是：" + result);
    }

    //定义一个方法，用于递归求阶乘，参数为一个int类型的变量
    public static int jc(int n) {
    
    
        //在方法内部判断该变量的值是否是1
        if(n == 1) {
    
    
            //是：返回1
            return 1;
        } else {
    
    
            //不是：返回n*(n-1)!
            return n*jc(n-1);
        }
    }
}