数据结构与算法之递归

递归

1.递归应用场景：

​ 迷宫回溯问题，递归（rescursion）

2.递归的概念：

​ 简单的说：递归就是方法自己调用自己，每次调用时传入不同的变量，递归有助于编程者解决复杂的问题，同时可以让代码变得更简洁。

3.递归调用机制：

​ 1.打印问题：

public static void test(int n) {    
    if (n >= 2) {       
        test(n - 1);  //运行到此处会将方法递归调用完，最后才会进行下面的打印输出操作 (所以打印结果为1、2、3.。。 )    
    }    
    System.out.println("n=" + n);
}

示意图：

2.阶乘问题：

public static int factorial(int n) {    
    if (n == 1) {        
        return 1;    
    } else {        
        return factorial(n - 1) * n; // 1*2*3*4    
    }
}

4.递归能解决什么样的问题

​ 1.各种数学问题，如：8皇后问题、汉诺塔问题、阶乘问题、迷宫问题、球和篮子问题

​ 2.各种算法中也可能用到递归：快排、归并排序、二分查找、分治算法等

​ 3.将用栈解决的问题

5.递归需要遵守的重要规则

​ 1.执行一个方法时，就创建一个新的受保护的独立的空间(栈空间)

​ 2.方法的局部变量是独立的，不会互相影响

​ 3.递归必须向退出递归的条件逼近，否则就是无限递归：死循环

​ 4.当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行

​ 完毕或者返回时，该方法也执行完毕。

​ 5.如果方法中使用的是引用类型的变量，就会共享该引用类型的数据。比如数组

6.递归-迷宫回溯问题

​ 1.示意图

2.代码实现：

public class maze {
    public static void main(String[] args) {
        //二维数组构建迷宫
        //地图
        int[][] map = new int[8][7];
        //使用1表示墙（无法通过）
        //上下全部置为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;

        //打印地图
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 7; j++) {
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }
        setWay(map,1,1);

        //输出新的地图
        System.out.println("小球走过的地图");
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 7; j++) {
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }
    }

    /**
     *   从[1][1] 出发，如果能到达[6][5] 则找到通路 当该值为0 表示没走过，如果为1，表示墙，为2表示可以走，为3表示已经走过，但走不通了
     *   下右上左的顺序去试探路线如果该点走不通，再回溯
     * @param map 地图
     * @param i 当前所处位置
     * @param j 位置
     * @return 找到通路，返回true，否则返回false
     */
        public static boolean setWay(int[][] map,int i,int j){
            if (map[6][5] == 2){
                return true;
            } else {
                if (map[i][j] == 0){ //当前结点没走过
                    map[i][j] = 2; //假定该点可走通
                    if (setWay(map,i+1,j)){ //下
                        return true;
                    } else if (setWay(map,i,j+1)){ //右
                        return true;
                    } else if (setWay(map,i-1,j)){ //上
                        return true;
                    } else if (setWay(map,i,j-1)){ //左
                        return true;
                    } else { //该点走不通
                        map[i][j] = 3;
                    }
                } else { //如果map[i][j] != 0 可能是1，2，3
                    return false;
                }
            }
            return false;
        }
}

3.代码实现：

​ 1.小球得到得路径，和设定的递归策略有关，找前后左右的顺序

​ 2.再得到小球路径时，可以先使用（下左上右），再改成（上右下左），看看路径是否有变化

​ 3.测试回溯现象

​ 4.思考：如何求出最短路径？

​ 解答：用四种策略都走一遍迷宫，记录走过的结点数，得到最少的节点数即为最短路径(暴力)