第8讲 递归（回溯）

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

递归需要遵守的重要规则

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

方法的局部变量是独立的，不会相互影响, 比如n变量

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

递归必须向退出递归的条件逼近，否则就是无限递归,出现StackOverflowError，死龟了:)

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

迷宫问题：

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;
        }
        for (int i = 0; i <7 ; 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("--------------小球走过并标识过的路------------");
        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 起始位置(1,1) 终止位置：(6,5)
     * 约定：map[i][j]==0时 表示还没走过 1:表示墙  2：通路可以走  3.表示已经走过 走不通
     *  确定策略 下-->右-->上-->左  如果该点走不通 再回溯
     */
    //使用递归回溯给小球找路
    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;
                    return false;
                }
            }else {
                //如果map[i][j]!=0 可能 1 2 3
                return false;
            }
        }
    }
}

八皇后问题：

八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出：在8×8格的国际象棋上摆放八个皇后，使其不能互相攻击，即：任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。

public class Queue8 {
    int max=8;
    private int[] array=new int[max];
    static int count=0;

    public static void main(String[] args) {
        Queue8 queue8 = new Queue8();
        queue8.check(0);
        System.out.println("解法次数："+count);
    }

    //编写一个方法，放置第n个皇后
    //check每一次递归 进入check都有for 因此会都有回溯
    private void check(int n){
        if(n==max){
            //8个皇后已经放好了
            printf();
            return;
        }
        //依次放入皇后 并判断是否冲突
        for(int i=0;i<max;i++){
            //先把当前这个皇后n,放到改行的第1列
            array[n]=i;
            //判断放入第n个皇后到i列时  是否冲突
            if (judge(n)) {
                //不冲突 接着放n+1个皇后
                check(n+1);
            }
            //如果冲突 继续执行array[n]=i; 即 将第n个皇后放置在本行的后移一个位置
        }
    }

    /**
     * n 表示n个皇后
     * @param n
     * @return
     */
    //查看当我们放置第n个皇后时,检测该皇后是否与前面的皇后冲突
    private boolean judge(int n){
        for (int i = 0; i < n ; i++) {
            //array[i]==array[n] 判断第n个皇后是否和第n-1个皇后在同一列
            //Math.abs(n-i)==Math.abs(array[n]-array[i]) 判断是否在同一斜线
            //判断是否在同一行
            if(array[i]==array[n]||Math.abs(n-i)==Math.abs(array[n]-array[i])){
                return false;
            }

        }
        return true;
    }
    
    //将皇后摆放的位置输出
    private void printf(){
        count++;
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }
}