数据结构与算法之递归与回溯

递归机制

简单点说就是一个函数调用自己
百度上盗个原理图

当然，每使用一个函数，都会创建一个新的空间(栈)
每个空间的数据(局部变量)，是独立的

递归的应用场景

• 各种各样的数学问题: 8皇后问题，汉诺塔，阶乘问题，迷宫问题，球和篮子的问题。
• 各种算法中也会使用到递归，比如快排，归并排序，二分查找，分治算法等。
• 将用栈解决的问题–>递归代码比较简洁

使用递归需要遵循的规则

• 执行一个方法时，就创建了一个栈空间
• 方法的局部变量是独立的，不会相互影响，比如n变量
• 如果方法中使用的是引用类型变量，就会共享该引用类型的数据(比如数组)
• 递归必须向退出递归的条件逼近，否则就是无限递归
• 当一个方法执行完毕时，或者遇到return，就会返回，遵守谁调用，就把结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕了

迷宫问题

说明: 在一个迷宫里面得到一条可行的路径,比如在一个6x5方格里面从最左上角走到最右下角的路径。
代码实现:

package recursion;

public class MiGong {
    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;

        // 输出地图
        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();
        }

        // 使用递归回溯给小球找路
        setWay(map,1,1);

        // 输出新的地图，小球走过并标识过的地图
        System.out.println("小球走过并标识过的地图");
        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();
        }

    }

    /**
     * @param map 表示地图
     * @param i   从哪个位置开始找
     * @param j
     * @return 如果找到通路，就返回true，否则返回false
     */
    // 使用递归回溯来给小球找路
    // 如果小球能到map[6][5]的位置，则说明通路找到
    // 走迷宫时，需要确定一个策略 下->右->上->左
    public static boolean setWay(int[][] map, int i, int j) {
        if (map[6][5] == 2) { // 通路已经找到ok
            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;
                    return false;
                }
            } else { // 如果map[i][j] != 0, 可能是 1,2,3
                return false;
            }
        }
    }
}

图形解析:
我们创建一个这样的迷宫(墙对应二维数组中元素的值为1的地方，空白的位置都对应着零)

以下的图文都为了解析

public static boolean setWay(int[][] map, int i, int j) {
        if (map[6][5] == 2) { // 通路已经找到ok
            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;
                    return false;
                }
            } else { // 如果map[i][j] != 0, 可能是 1,2,3
                return false;
            }
        }
    }

我们从左上角开始出发！

setWay(map,1,1);

首先我们先给当前的元素赋值为2(对应下图把空白的地方变为蓝色)

往下走，进入if语句的第一条

setWay(map, i+1, j) // 此时传进去的参数分别是map,2,1

进入函数中，因为 第三行第二列的元素为0,先给它赋值2

然后进入第一层if语句中(看上面的代码),然后再一次运行

setWay(map, i+1, j) // 此时传进去的参数分别是map,3,1

因为我们知道，第四行第二列是墙(对应元素的值为1),于是我们在判断第一层if的时候,因为该元素的值不为0，然后直接返回 false , 于是返回到该函数的上一级(此时回到了 setWay(map, 2, 1))的

else if (setWay(map,i,j+1)) // 此时传进去的值是 map,2,2

然后发现 第三行第三列的元素为0，进入第一层if，先给这个元素赋值2

然后继续判断

setWay(map, i+1, j) // 此时传入的参数是 map,3,2

发现还是不行，然后返回上一层，来到

else if (setWay(map,i,j+1)) // 此时传入的参数是 map,3,3

发现第四行第四列的元素为0，进入第一层判断，先把该元素赋个2

以此类推
最后我们可以得到

当然来到第七行第六列的时候，我们直接返回一个true 从此结束。

死路的情况(回溯)

这里我们设置一个死路

当我们运行函数的时候，我们会来到这里

然后当我们运行

setWay(map, 1, 2)

会发现

// 按照策略走 下->右->上->左
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;
    return false;
}

上面四种判断都无法实现，最后来到 else 语句中 给该元素赋值3，然后返回false到上一层

setWay(map, 1, 1)

对于这一层来说 它此时接收到

setWay(map, i+1, j) // 对应的是 map,2,1

返回的false，然后继续进行 else if 语句判断下一级，当然，到最后我们同样会返回false
于是我们可以得到

黄色区域代表元素的值为3,死路

思考

如果我们想要求出最短路程，我们需要修改的其实是那四个上下左右走的策略。
于是我们可以求出这四个策略的全排列，利用栈将顺序都保存在List中

package recursion;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;


public class test {
    public static List<Stack> list = new ArrayList<>();
    public static Stack<Integer> stack = new Stack<Integer>();
    public static void main(String[] args) {
        int shu[] = {1,2,3,4};
        f(shu,4,0);
        System.out.println(list);

    }
    /**
     *
     * @param shu   待选择的数组
     * @param targ  要选择多少个数
     * @param cur   当前选择的是第几次
     */
    private static void f(int[] shu, int targ, int cur) {
        if(cur == targ) {
            list.add((Stack) stack.clone());
            System.out.println(stack);
            return;
        }
        for(int i=0;i<shu.length;i++) {
            if(!stack.contains(shu[i])) {
                stack.add(shu[i]);
                f(shu, targ, cur+1);
                stack.pop();
            }
        }
    }
}

然后分别利用1-4这四个数字代表上下左右，按照24组不同顺序的策略依次测试，每走完一遍就记录下一遍路程，最后得出最短路程