用递归解决迷宫问题，以及我对递归的一些思考（Java日记Ⅶ）

递归比循环难，首先是想不到使用递归，其次是递归比循环更绕，一不小心就会死龟，究其原因是一个视角的问题，所谓当局者迷，旁观者清，当我们在写循环的时候使用的是上帝视角，我们知道只有在循环体内的代码会被反复执行，而在使用递归时，我们是第一人称视角，我们所书写的函数中所有的代码都在循环写一个循环一个，所以感觉很乱不知道如何下手。

我自己的解决方案：调整视角，将自己置于全局，而不是函数中，把递归想象成一个参数不断变化的循环

在思考递归时想象自己在debug调试，每一次进入递归的入口它的上一次都卡在某个if中还没有return，直到递归条件不在满足，将会发生连锁反应，回到前面的if的下一个if的条件处继续判断，直到找到出口或找到自己设置的假出口。

1.写递归首先要做的就是设置出口，多使用if分区把递归的循环主体限制在某个if中，每个if都要有出口，前期写的时候尽量不要去简化，多使用return，以能运行为第一目的

2.写递归的时候只需要关注自己当前循环、上一次循环和下一次循环，千万千万不要多想，一不小心就会把自己代入。

3.不要想着一次性把代码写完，那几乎是不可能的，写完一个if就验证一下，首先确定自己已经写的代码没有问题，一点一点调试不要觉得浪费时间，否则后面花费的时间只会更多

4.递归里尽量不要写循环，递归的深度不能太深，递归一定要让条件在某一时刻不在满足，在用循环解决参数变化的问题时要想到递归，在有砍木头的问题（平方问题，把一根木头一分为二，再把每段一分为二，无限循环直到每一段符合长度要求，快速排序就用到了这个思想）时要想到递归，还有许多许多情况时要有想到递归，经验还不是很足，先写到这，以后继续总结。

学的越多越会发现递归其实不难，难的是绝大多数时候你想不到用它，一般我们都是在使用循环无法解决某个问题或者很麻烦的时候才会想到是否可以用递归解决，所以递归一般都被用作备选方案，但其实这种思想并不是正确的，符合递归规则的最好优先使用递归，这些规则需要我们在学习过程中自己总结，以上内容仅是我自己当时的思考，仅供参考，我后续会不断更正自己的思维方式，不排除推翻当前思维的可能。最后一句提醒：千万不要封锁自己思维，唯有变化才是永恒不变的。

实例1：用递归解决迷宫问题

public class MazeBack {
    public static void main(String[] args) {
        int[][] map=getMap();
        setWall(map);
        findWay(map,1,0);
        showMap(map);
    }
    public static void showMap(int[][] map){
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                if(map[i][j]==2){
                    System.out.print("\033[32m"+map[i][j]+"\t");
                }else if(map[i][j]==3){
                    System.out.print("\033[31m"+map[i][j]+"\t");
                }
                else if(map[i][j]==0){
                    System.out.print("\033[33m"+map[i][j]+"\t");

                }
                else {
                    System.out.print("\033[34m"+map[i][j]+"\t");
                }
            }
            System.out.println("\n");
        }
    }
    public static int[][] getMap(){
        int[][] arr=new int[10][10];
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                if(i==0||j==0||i==9||j==9){
                    arr[i][j]=1;
                    continue;
                }
                arr[i][j]=0;
            }
        }
        arr[1][0]=0;
        arr[8][0]=0;
        return arr;
    }
    public static void setWall(int[][] map){
        for (int i = 1; i < 9; i++) {
            map[5][i]=1;
        }
        for (int i = 0; i < 5; i++) {
            map[3][i]=1;
        }
        map[2][4]=1;
        map[2][5]=1;
        map[2][6]=1;
        map[3][8]=1;
        map[4][6]=1;
        map[4][7]=1;
        map[4][8]=1;
        map[5][5]=0;
        map[6][4]=1;
        map[7][4]=1;
        map[8][4]=1;
        map[6][1]=1;
        map[7][1]=1;
        map[7][2]=1;
        map[5][2]=0;

    }
    public static boolean findWay(int[][] map,int x,int y){
        if(x==8&&y==0){
            map[x][y]=2;
            return true;
        }
        else if(map[x][y]==0){
            map[x][y]=2;
            if(findWay(map,x+1,y)){
                return true;
            }
            else if(findWay(map,x,y+1)){
                return true;
            }
            else if(findWay(map,x-1,y)){
                return true;
            }
            else if(findWay(map,x,y-1)){
                return true;
            }
            else {
                map[x][y]=3;//上一次递归遇到死路，将当前位置标记为3，引发连锁反应会将之前走过的路全部标记为3，直到找到上一个路口，调整方向后继续走
                return false;
            }
        }
        else {
            //死路退回到上个位置
            return false;
        }
    }
}