java:递归的结构--基础篇

递归结构：

   递归的基本思想就是“自己调用自己”

【示例1-1】

public static void main(String[] args) {
        a();
}
static void a(){
        System.out.println("a");
        a();
}

如上示例，将会报错java.lang.StackOverflowError的错吴，错误的原因：是由于a方法一直调用a方法，而没有释放，导致内存不足，才产生的错误。

递归结构分为两部分：

    1.定义递归头：解答：什么时候不调用自身方法，如果没有头，将陷入死循环，也就是递归的结束条件。

    2.递归体：解答：什么时候需要调用自身的方法

【示例1-2】递归基本结构

 

public static void main(String[] args) {
        a();
}
static int count = 0;
static void a(){
        count++;
        System.out.println("a");
        if(count < 5){
            a();
        }else{
            return;
        }
}

 

【示例1-3】递归：解析

public static void main(String[] args) {
        System.out.printf("%d阶乘的结果：%s%n",5,factoria(5));
        factoria(5);
}
static long factoria(int n){
        if(n == 1){
            return 1;
        }else{
            return n * factoria(n - 1);
        }
}

执行结果：

       5阶乘的结果：120

递归运行分析图：

 

递归缺陷：

简单的程序是递归的优点之一，但递归的调用会占大量的系统栈堆，内存耗用多，在递归调用层次多时速度要比循环慢的多，所以在使用递归时需慎重。

【示例1-4】递归运行效率与普通循环效率对比

public static void main(String[] args) {
        long d1 = System.currentTimeMillis();
        System.out.printf("%d阶乘的结果：%s%n",10,factoria(10));
        long d2 = System.currentTimeMillis();
        System.out.printf("递归费时：%s%n",d2-d1);
        factoria(5);
        factoriaLong(10);
}
static long factoria(int n){
        if(n == 1){
            return 1;
        }else{
            return n * factoria(n - 1);
        }
}
    
static long factoriaLong(int a){
        long d3 = System.currentTimeMillis();
        long res = 1;
        while(a > 1){
            res *= a * (a - 1);
            a -= 2;
        }
        long d4 = System.currentTimeMillis();
        System.out.println(res);
        System.out.printf("普通循环费时：%s%n",d4-d3);
        return res;
}

执行结果：

        10阶乘的结果：3628800

    递归费时：31

        3628800

    普通循环费时：1

注意：

任何能用递归解决的问题也能使用迭代解决。当递归方法可以更加自然的反映问题，并且易于理解和调试，不强调效率问题时，可以采用递归。

在要求高性能的情况下尽量避免使用递归，递归调用既花时间又耗内存。

 

转载于:https://www.cnblogs.com/wangjiachun2017/p/10230987.html