函数的递归调用

1.打印问题

(1)初始问题 

public class recursion {
    public static void main(String[] args){
        T t1 = new T();
        t1.test(4);
    }
}

class T {
    public void test(int n){
        if(n > 2){
            test(n - 1);
        }
        System.out.println("n=" + n);
    }
}

如上代码所示：

递归调用test函数，将每部分的值依次压入栈中，分别为 n=4, n=3, n=2，由于栈的特性先入后出，输出结果依次为 n=2, n=3, n=4。

 

（2）问题延伸

 在test函数里加入else:

public class recursion {
    public static void main(String[] args){
        T t1 = new T();
        t1.test(4);
    }
}

class T {
    public void test(int n) {
        if (n > 2) {
            test(n - 1);
        } else {
            System.out.println("n=" + n);
        }
    }
}

 每个栈不会完整的执行输出语句，最终输出栈顶元素n=2。

 

2.阶乘问题

public class recursion {
    public static void main(String[] args){
        T t1 = new T();
        int res = t1.factorial(5);
        System.out.println("res=" + res);
    }
}

class T {
        public int factorial(int n){
        if (n == 1){
            return 1;
        }else{
            return  factorial(n - 1) * n;
        }
    }
}

如上述代码所示：

运行流程在栈中的情况大致为：

n=1

return 1

n=2

f(1）*  2 = 2

n=3

f(2)  *  3 = 6

n=4

f(3)  *  4 = 24

n=5

f(4)  *  5 = 120

main

f(5)=120

out -> 120

3.递归的相关练习

（1）斐波那契数列

public class RecursionExercise01 {
    public static void main(String args[]){
        T t1 = new T();
        int n = 0;
        int res = t1.fibonacci(n);
        if(res != -1){
            System.out.println("当n=" + n +"对应的斐波那契数=" + res);
        }
    }
}

class T{
    public int fibonacci(int n) {
        if (n >= 1) {
            if (n == 1 || n == 2) {
                return 1;
            } else {
                return fibonacci(n - 1) + fibonacci(n - 2);
            }
        } else {
            System.out.println("要求输入的n>=1的整数");
            return -1;
        }
    }
}

如上图所示，控制输入的变量为n，从而达到求出所给整数的所有项相加的和；当输入的整数小于1，即不满足斐波那契数列的基本条件时，提示应输出大于等于1的整数。

 

 （2）猴子吃桃子

public class RecursionExercise02 {
    public static void main(String args[]){
        T2 t = new T2();
        int day = 1;
        int peachNum = t.peach(day);
        if(peachNum != -1){
            System.out.println("第" +day + "天有" + peachNum + "个桃子");
        }
    }
}

class T2{
    public int peach(int day){
        if(day == 10){
            return 1;
        } else if (day >= 1 && day <=9) {
            return (peach(day + 1) + 1) * 2;
        } else{
            System.out.println("day在1-10");
            return -1;
        }
    }
}

 猴子吃桃子问题：有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个！以后每天猴子都吃其中的一半，然后再多吃一个。当到第十天时，发现只有一个桃子了。问最初共多少个桃子？

这里用逆推的思路分析：

1.day = 10 时有1个桃子

2.day = 9 时有（day10 + 1）* 2 = 4

3.day = 8 时有（day9 + 1）* 2 =10

........

综上所述，发现规律是 前一天的桃子 = （后一天的桃子 + 1）* 2

然后递归

如输入的数不满足条件，则输出day应该在1-10之间。

（3）迷宫问题

public class MiGong {
    public static void main(String[] args){
        //规定 map 数组的元素值：0表示可以走，1表示障碍物

        int[][] map = new int[8][7];
        //将最上面的一行和最下面的一行，全部设置为1
        for (int i = 0; i < 7; i++){
            map[0][i] = 1;
            map[7][i] = 1;
        }
        //将最右面的一行和最左面的一行，全部设置为1
        for (int i = 0; i < 8; i++){
            map[i][0] = 1;
            map[i][6] = 1;
        }
        map[3][1] = 1;
        map[3][2] = 1;

        //输出当前的地图
        System.out.println("=======当前地图情况========");
        for(int i = 0; i < map.length; i++){
            for(int j = 0; j < map[i].length; j++){
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }

        //使用findWay给老鼠找路
        T3 t = new T3();
        t.findWay(map, 1, 1);

        System.out.println("========找路的情况如下========");

        for(int i = 0; i < map.length; i++){
            for(int j = 0; j < map[i].length; j++){
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }
    }
}

class T3{

    //使用递归回溯的思想来解决老鼠出迷宫

    //如果找到，就返回true ，否则返回false
    //i,j 就是老鼠的位置，初始化的位置为（1，1）
    //因为我们是递归的找路，所以我先规定 map数组的各个值的含义
    // 0 表示可以走 1 表示障碍物 2表示可以走 3表示走过，但是走不通是死路
    //当map[6][5] = 2 就说明找到通路，就可以结束，否则就继续找
    //先确定老鼠找路策略 下->右->上->左
    public boolean findWay(int[][] map , int i, int j){

        if(map[6][5] == 2){//说明已经找到
            return true;
        }else{
            if(map[i][j] == 0) {//当前这个位置0，说明表示可以走
                //假定可以走通
                map[i][j] = 2;
                //使用找路策略，确定该位置是否真的可以走通
                //下->右->上->左
                if(findWay(map,i + 1, j)){//先走下
                    return true;
                } else if(findWay(map, i, j + 1)){//右
                    return true;
                } else if (findWay(map,i - 1, j)) {//上
                    return true;
                } else if (findWay(map,i , j - 1)) {//左
                    return true;
                } else{
                    map[i][j] = 3;
                    return false;
                }
            }else{ //map[i][j] = 1, 2, 3
                return false;
            }
        }
    }
}

出迷宫代码如上所示：

处理该问题时，首先需要构建地图，用0，1来设计地图范围；然后制定规则，将可以走，不能走，死路等均用特定数字来标识；最后制定寻路规则，图中所示我制定的规则是下->右->上->左，制定不同寻路规则得到的路线不同。 

（4）汉诺塔问题

public class HanoiTower {
    public static void main(String[] args){
        Tower tower = new Tower();
        tower.move(3, 'A', 'B', 'C');
    }
}

class Tower{

    //num表示要移动的个数，a，b，c 分别表示A塔， B塔， C塔
    public void move(int num, char a, char b, char c){
        //如果只有一个盘 num = 1
        if(num == 1){
            System.out.println(a + "->" + c);
        } else{
            //如果有多个盘，可以看成两个，最下面的和上面的所有盘(num-1)
            //（1）先移动上面所有的盘到 b，借助 c
            move(num - 1, a, c, b);
            //(2)把最下面的这个盘，移动到c
            System.out.println(a + "->" + c);
            //(3)再把 b塔的所有盘，移动到c， 借助a
            move(num - 1, b, a, c);
        }
    }

}

如图所示，设定了三个盘进行移动，主要方法是借助一根柱子进行盘子的转移，先借助c将a上的盘到b，再将a上最下面的盘移动到c，最后借助a将b的所有盘移动到c。