Java笔记 —— 递归

递归与嵌套的区别

递归： 方法定义本身调用方法本身的现象叫递归
方法嵌套：Math.max(Math.max(a,b),c); 这仅仅是方法的嵌套使用

递归的注意点：

1. 递归一定要有一个出口，也就是结束条件，否则就是死循环。可以用System.exit(0);退出递归调用
2. 递归的次数不能太多，否则就会发生内存溢出。因为每次递归都会占用一定的栈内存
3. 构造方法不能递归使用

递归的思路：

1. 第一件事，需要明确递归方法的功能。
   比如说这个方法是要计算一个数的平方，是要计算两个数的和
2. 第二件事，需要确定递归方法的停止条件
   不能让递归无休止的调用下去，这样会造成内存溢出报错
3. 第三件事，分解这个递归方法，不断缩小方法参数的范围，直到抵达停止条件。（寻找等价替代的关系表达式）
   比如递归方法的作用是求取数列中的某一个数，这个数是由数列的前两个数相加而得
   那么递归函数就可以由 func(i) 改为 func(i-1) + func(i-2)

递归实例一

打印数值，从10到1
思路：

1. 这个方法的作用是将参数列表中的 i 打印出来
2. 这个方法的停止条件是 i == 1的时候
3. 这个方法的参数要不断缩小范围，这样才能抵达停止条件，那么就是 show( i ) ——> show( i - 1 )

package test.RecursionDemo;

public class Demo {
    public static void main(String[] args) {
        show(10);
    }

    public static void show(int i){
        if(i==0){
            System.exit(0);
        }else{
            System.out.println(i);
            show(i-1);
        }
    }
}

实例二

递归求阶乘
思路：

1. 方法的作用是求方法参数 i 的阶乘
2. 方法的停止条件是 i = 1的时候
   因为5！= 5 * 4 * 3 * 2 * 1 到 1 为止
3. 方法的参数要缩小范围，寻找等价替代的关系表达式
   这里分析一下
   5！= 5 * 4 * 3 * 2 * 1 = 120
   = 5 * 4！
   = 5 * 4 * 3！
   = 5 * 4 * 3 * 2！
   = 5 * 4 * 3 * 2 * 1！
   可以发现 mul( i ) 可以等价替换为 i * mul( i - 1 )

第一个数是5，5不满足停止条件，因此return 5 * mul（4），这里的5是 i，而mul（4）是 4的阶乘

package test.RecursionDemo;

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

结果为120，和预期一致

另外写一下，如果不用递归调用应该怎么实现

public class Demo {
    public static void main(String[] args) {
        int result = 1;
        for(int i=2;i<=5;i++){
            result = result*i;
        }
        System.out.println(result);
    }
}

实例三

斐波那契数列 1，1，2，3，5，8，13，21……
思路：

1. 方法的作用是求取数列中的某一个数
2. 数列的停止条件是 i == 1 | i == 2，这是数列的前两个数，再往前就没有了，所以是停止条件
3. 分解思想，缩小方法参数范围，寻找函数的等价替代式
   先来通过观察，找到斐波那契数列的规律，即从第三个数开始，每个数都是前两个数字之和
   有了这个规律后，我们就可以将 func( i ) 分解为 func( i - 1 )和 func( i - 2 )

package test.RecursionDemo;

//斐波那契数列，1,1,2,3,5,8……
public class Demo2 {
    public static void main(String[] args) {
        int result = Fibonacci(8);
        System.out.println(result);
    }

    public static int Fibonacci(int i){
        if(i==1 | i==2){
            return 1;
        }else{
            return Fibonacci(i-2) + Fibonacci(i-1);
        }
    }
}

传入 i 的值为8后，将Fibonacci( 8 )分解为Fibonacci( 7 )+Fibonacci( 6 )
Fibonacci( 7 )也是一个递归方法，将会被分解为 Fibonacci( 6 ) + Fibonacci( 5 )得到Fibonacci( 7 )的值
依次类推得到Fibonacci( 6 )的值，从而得到Fibonacci( 8 )的值
而这个依次类推的过程会在Fibonacci( 1 )和Fibonacci( 2 )相加的时候停止

最后的结果为 21

还是写上一下，如果不使用递归调用应该怎么处理
方法一、数组方式实现

package test.RecursionDemo;
public class Demo2 {
    public static void main(String[] args) {
        //方法一、用数组实现
        int[] arr = new int[8];
        arr[0] = 1;
        arr[1] = 1;

        for (int i = 2; i < arr.length; i++) {
            arr[i] = arr[i - 2] + arr[i - 1];
        }
        System.out.println("结果为" + arr[7]); 

        System.out.println("----------------------");

        //方法二、基本变量实现
        //下一次的相邻数据a是上一次相邻数据的b的值，下一次相邻数据的b是上一次的a+b
        int a = 1;
        int b = 1;
        //八个数字，相加了6次
        for (int i = 0; i < 6; i++) {
            //定义一个临时变量 保存上一次a的值
            int temp = a;
            a = b;
            b = temp + b;
        }
        System.out.println("结果为" + b);
    }
}

实例四

打印文件目录中所有以.txt为结尾的文件

package test.RecursionDemo;

import java.io.File;
public class Demo3 {
    public static void main(String[] args) {
        File file = new File("D:\\java\\demo1");
        //1.获取指定目录下的所有File对象，放入File数组中
        File[] files = file.listFiles();
        show(files);

    }

    public static void show(File[] files){
    //遍历File数组中的每一个File对象
        for(File file1 : files){
        //如果File对象是文件夹，那么继续往这个文件夹里面遍历
            if(file1.isDirectory()){
                show(file1.listFiles());
            }else{
            //否则，也就是File对象是文件时，判断后缀名是不是.txt
            //如果是则打印
                if(file1.getName().endsWith(".txt")){
                    System.out.println(file1.getName());
                }
            }
        }
    }
}

实例五

当文件里面不为空的时候，通过遍历删除此文件里面的所有内容，从而删除这个文件

package test.RecursionDemo;

import java.io.File;

public class Demo6 {
    public static void main(String[] args) {
        File file = new File("D:\\java\\demo1");
        deleteDemo(file);
    }

    public static void deleteDemo(File file){
    //获取当前文件夹中的所有内容
    //这里的当前文件夹，最开始是demo1文件夹，到后面被递归调用的时候，就变成demo1的子文件夹
        File[] files = file.listFiles();
        //当File数组不为空的时候，遍历所有File对象
        //如果是文件夹，则递归调用方法，进入此文件夹里面，删除里面的所有内容
        //如果是文件，则用delete()方法直接删除
        if(files!=null){
            for(File f : files){
                if(f.isDirectory()){
                    deleteDemo(f);
                }else{
                    f.delete();
                }
            }
        }
        //文件夹里面为空时，也就是File[]数组为空时，删除此文件夹
        file.delete();

    }
}