D4-递归[Java数据结构和算法]

1.递归

　　1.1 递归就是方法自己调用自己，每次调用时传入不同的变量

　　1.2 递归调用规则：

　　（1）当程序执行到一个方法时，就会开辟一个独立的空间（栈）

　　（2）每个空间的数据（局部变量）是独立的。

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

　　（4）递归必须需向退出递归的条件逼近，否则就是无限递归

　　（5）当一个方法执行完毕，或者遇到return，就会返回。遵守谁调用，就将结果返回谁。

　　1.3 递归可以解决的问题

　　（1）各种数学问题：八皇后问题，汉诺塔，阶乘，迷宫，球和篮子的问题等

　　（2）各种算法中：快排，归并排序，二分查找，分治算法

　　（3）用栈解决的问题->递归算法比较简洁

2.迷宫问题

package cn.atguigu.recusrion;

public class MiGong {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //创建二维数组，模拟迷宫
        //地图
        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;
        map[1][2]=1;
        map[2][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();
        }
    }
    
    //使用递归回溯来给小球找路
    //说明
    //1.map表示地图
    //2.i,j表示从地图哪个位置开始出发(i,j)
    //3.如果小球能到map[6][5]，则说明通路找到
    //4.约定：当map[i][j]为0表示点没有走过，当为1表示墙；2表示通路可以走；3表示该点已经走过，但是走不通
    //5.在走迷宫时，需要确定一个策略（方法）,下->右->上->左，如果该点走不通，再回溯
    /**
     * 
     * @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;//该点不通，置3
                    return false;
                }
            }else {//如果map[i][j]!=0,可能是1,2,3
                return false;
            }
        }
    }

}

3.八皇后问题：8*8的棋盘上摆放8个皇后，任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种解法(92)

　　3.1 思路分析

　　（1）第一个皇后先放第一行第一列

　　（2）第二个皇后放在第二行第一列，然后判断是否ok，如果不ok，继续放在第二列、第三列、依次把所有列都放完，找到一个合适

　　（3）继续第三个皇后，还是把第一列，第二列...直到第八个皇后也能放在一个不冲突的位置，算是找到了一个正确解

　　（4）当得到一个正确解时，在栈回退到上一个栈时，就会开始回溯，即将第一个皇后，放到第一列的所有解，全部得到。

　　（5）然后回头继续第一个皇后放第二列，后面继续循环执行1,2,3,4的步骤

　　　说明：用一维数组解决，对应的下标表是第几行，即第几个皇后，val表示第i+1个皇后在第几列

 　　3.2源代码

package cn.atguigu.recusrion;

public class Queue8 {
    //定义一个max表示共有多少个皇后
    int max=8;
    //定义数组array，表示皇后放置位置的结果，比如arr={0,4,,7,5,2,6,1,3}
    int[] array=new int[max];
    static int count=0;
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Queue8 queue=new Queue8();
        queue.check(0);
        System.out.printf("一共有%d解法",count);
        
    }
    //编写一个方法，放置第n个皇后
    private void check(int n) {
        if(n==max) {//n=8，8个皇后就已经放好
            print();
            count++;
            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个皇后，就去检测该皇后是否与前面摆放的皇后是否冲突
    /**
     * 
     * @param n 表示第n个皇后
     * @return
     */
    private boolean judge(int n) {
        for (int i = 0; i < n; i++) {
            //说明
            //1.array[i]==array[n] 表示判断第n个皇后是否和前面的n-1个皇后在同一列
            //2.Math.abs(n-i)==Math.abs(array[n]-array[i]) 表示判断第n个皇后和第i个皇后是否在同一斜线
            if(array[i]==array[n]||Math.abs(n-i)==Math.abs(array[n]-array[i])) {
                return false;
            }
        }
        return true;
    }
    
    //写一个方法，将皇后摆放的位置输出
    private void print() {
        for(int i=0;i<array.length;i++) {
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }
}