
public class Test {
    public static void main(String[] args) {
        int n = 3;
        int ret = fac(n);
        System.out.println(ret);//6
    }
 
    public static int fac(int n){
        if(n == 1){
            return 1;
        }
        return n * fac(n-1);//fac调用函数自身
    }
}

递归的详细操作：（用三个图详解）

2.2 按顺序打印一个数字的每一位（1234）


public class Test {
    public static void main(String[] args) {
        int n = 1234;
        num(n);
    }
    public static void num(int n){
        if(n >= 9){
            num(n/10);
        }
        System.out.println(n % 10);
    }
 
}

2.3 递归求1+2+3+4+...+10


public class Test {
    public static void main(String[] args) {
        int sum = 10;
        int ret = sum(10);
        System.out.println(ret);
    }
    public static int sum(int n){
        if(n == 1){
            return n;
        }
        else{
            return n + sum(n-1);
        }
    }
}

2.4 写一个递归方法，输入一个非负整数，返回组成它的数字之和. 例如，输入 1729, 则应该返回 1+7+2+9，它的和是19


public class Test {
    public static void main(String[] args) {
        int n = 1729;
        int ret = sum(n);
        System.out.println(ret);
    }
    public static int sum(int num){
        if(num < 10){
            return num;
        }
        return num % 10 + sum(num / 10);
    }
 
}

2.5 求斐波那契数列的第 N 项


public class Test {
    public static void main(String[] args) {
        System.out.println(fib(5));
    }
    public static int fib(int n){
        if(n == 1){
            return 0;
        }
        if(n == 2){
            return 1;
        }
        return fib(n-1) + fib(n-2);
    }
}

那么既然递归如此方便，我们就要盲选递归么，当然不是，就拿斐波那契数列来说

看以下代码：


public class Test {
    public static int count = 0;
    public static void main(String[] args) {
        System.out.println(fib(40));
        System.out.println(count);
    }
    public static int fib(int n){
        if(n == 1){
            return 0;
        }
        if(n == 2){
            return 1;
        }
        if(n == 3){
            count++;
 
        }
        return fib(n-1) + fib(n-2);
    }
}

如上图运算结果所示当求fib(40)时，count出现了次，出现了冗余运算，此时的执行效率其实并不如循环方法。

那么让我们看看循环方法：


public class Test {
    public static void main(String[] args) {
        int n = 40;
        int ret = fib(n);
        System.out.println(ret);
    }
    public static int fib(int n){
        int l1 = 0;
        int l2 = 1;
        int l3 = 0;
        for(int i = 3; i <= n; i++){
            l3 = l1 + l2;
            l1 = l2;
            l2 = l3;
        }
        return l3;
    }
}

所以并不能盲选递归，当数据大的时候，其实循环效率会更高

声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】