java递归删除偶数 java递归次数限制

文章目录

• 一、递归

• 1.1 概述
• 1.2 递归导致栈内存溢出原理

• 二、递归累加求和

• 2.1 计算1 ~ n的和
• 2.2 代码执行图解

• 三、递归求阶乘
• 四、递归打印多级目录

一、递归

1.1 概述

• 递归：指在当前方法内调用自己的这种现象。
• 递归的分类:

• 递归分为两种，直接递归和间接递归。
• 直接递归称为方法自身调用自己。
• 间接递归可以A方法调用B方法，B方法调用C方法，C方法调用A方法。

• 注意事项：

• 递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。
• 在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出。
• 构造方法，禁止递归

• 使用前提 :
  当调用方法的时候，方法的主体不变，每次调用方法的参数不同，可以使用递归
• 代码演示：

class Demo01Recurison {
    public static void main(String[] args) {
        //a();
        b(1);
    }

    /*
        构造方法,禁止递归
            编译报错:构造方法是创建对象使用的,一直递归会导致内存中有无数多个对象,直接编译报错
     */
    public Demo01Recurison() {
        //Demo01Recurison();
    }

    /*
            在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出。
            11265
                Exception in thread "main" java.lang.StackOverflowError
         */
    private static void b(int i) {
        System.out.println(i);
        if(i==20000){
            return; //结束方法
        }
        b(++i);
    }

    /*
        递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。
        Exception in thread "main" java.lang.StackOverflowError
     */
    private static void a() {
        System.out.println("a方法!");
        a();
    }
}

1.2 递归导致栈内存溢出原理

上述的 a 方法会在栈内存中一直调用 a 方法，就会导致栈内存中有无数个 a 方法，方法太多，超出了栈内存的大小，就会导致内存溢出的错误。

注意：

    当一个方法调用其他方法的时候，被调用的方法没有执行完毕，当前方法会一直等待调用的方法执行完毕，才会继续执行。

二、递归累加求和

2.1 计算1 ~ n的和

• 分析：
  1+2+3+…+n
  n+(n-1)+(n-2)+…+1
  已知：最大值：n 最小值：1
  使用递归必须明确：

• 递归的结束条件
  获取到1的时候结束
• 递归的目的
  获取下一个被加的数字(n-1)

• 故 n 的累和 = n+ (n-1)的累和，且到 n=1 时结束

实现代码：

public class Demo02Recurison {
    public static void main(String[] args) {
        int s = sum(3);
        System.out.println(s);
    }
    /*
      通过递归算法实现.
      参数列表:int
      返回值类型: int
    */
    public static int sum(int n) {
      	/*
      	   n为1时,方法返回1,
      	   相当于是方法的出口,n总有是1的情况
      	*/
        if(n == 1){
            return 1;
        }
      	/*
          n不为1时,方法返回 n +(n-1)的累和
          递归调用sum方法
        */
        return n + sum(n-1);
    }
}

2.2 代码执行图解

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

三、递归求阶乘

• 阶乘：所有小于及等于该数的正整数的积。
  n的阶乘：n! = n * (n-1) … 3 * 2 * 1
• 分析：
  5的阶乘：5! = 5*(5-1)*(5-2)*(5-3)*(5-4) = 5*4*3*2*1

• 递归结束的条件
  获取到1的时候结束
• 递归的目的
  获取下一个被乘的数字(n-1)
• 方法的参数发生变化
  5，4，3，2，1

• 故推理得出：n! = n * (n-1)!

代码实现：

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);
    }
}

四、递归打印多级目录

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

代码实现：

ublic class Demo04Recurison {
    public static void main(String[] args) {
        // 创建File对象
        File dir  = new File("D:\\aaa");
        // 调用打印目录方法
        printDir(dir);
    }

    public static void  printDir(File dir) {
        System.out.println(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);
            }
        }
    }
}