【java数据结构】递归应用： 迷宫回溯问题和八皇后问题

目录

01 递归

1.1 递归的调用机制

1.2 递归能解决的问题

02 迷宫回溯问题

2.1 代码示例

 03 八皇后问题

3.1 八皇后算法思路分析

3.2 代码示例

---

01 递归

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

调用递归时需要有一个跳出递归的出口，否则会栈溢出

1.1 递归的调用机制

打印问题

阶乘问题

public class RecursionTest {
    
    public static void main(String[] args){
        test(4);
    }

    // 打印问题
    public static void test(int n){
        if(n > 2){  // 设置条件什么时候退出递归
            test(n - 1);
        }//else{  // 加else 只打印 2， 不加else 打印2 3 4
            System.out.println("n = " + n);
        //}
    }

    // 阶乘问题
    public static int factorial(int n){
        if(n == 1){   // 递归结束的条件
            return 1;
        } else{
            return factorial( n - 1) * n;   // factorial(2 - 1) * 2
        }
    }


}

1.2 递归能解决的问题

•  各种数学问题：八皇后问题，汉诺塔， 阶乘，迷宫问题
• 各种算法：快排， 归并排序，二分查找，分治算法
• 需要用栈解决的问题

注意事项

• 执行一次 方法时，就创建一个新的受保护的独立空间（栈）
• 方法中的局部变量是独立的，不会互相影响
• 如果方法中使用引用类型变量，就会共享该变量（数组）
• 递归必须向退出递归条件逼近，否则会无限递归： StackOverFlowError

02 迷宫回溯问题

 

 小球的到的路径与程序员是设置的找路策略有关，通过改变策略会得到不同的路径

2.1 代码示例

public class LabyrinthTest {
    public static void main(String[] args){
        // 先创建一个二维数组来模拟迷宫地图
        int[][] map =new int[8][7]; // 一个八行七列的地图
        printMap(map);

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

        // 打印路径
        System.out.println("路径如下");
        for(int i = 0; i < map.length ; i++){
            for(int j = 0; j < map[0].length; j++){
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }


    }

    // 使用递归回溯来给小球找路: 首先知道地图map，其次知道小球初始位置map[i][j]
    // 如果小球达到map[6][5],说明 找到通路
    // 数字1 表示 墙， 数字0 表示 没有走过， 数字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; // 如果可以向下走， 返回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;  // 上面都返回false说明 路走不通，设为3。
                    return false;
                }
            }else{  // 为 1 2 3
                return false;
            }

        }



    }

    public  static void printMap(int[][] map){
        //使用 1 表示墙，最外层
        // 上下两边
        for(int i = 0; i < map[0].length; i ++){  // map[0].length 表示二维数组的列
            map[0][i] = 1;
            map[7][i] = 1;
        }
        // 左右两边
        for(int i = 0;i < map.length; 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 < map.length ; i++){
            for(int j = 0; j < map[0].length; j++){
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }
    }

}

 03 八皇后问题

问题表述为：在8×8格的国际象棋上摆放8个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。

3.1 八皇后算法思路分析

• 当我们选择了第一个皇后的位置之后，与其处于同行同列同斜线的位置便都无法被选择，
• 第二个皇后只能放在未被第一个皇后所辐射到的位置上，
• 接着放置第三个皇后，同样不能放在被前两个皇后辐射到的位置上，
• 若此时已经没有未被辐射的位置能够被选择，也就意味着这种摆法是不可行的，我们需要回退到上一步，给第二个皇后重新选择一个未被第一个皇后辐射的位置，再来看是否有第三个皇后可以摆放的位置，如还是没有则再次回退至选择第二个皇后的位置，若第二个皇后也没有更多的选择则回退到第一个皇后，重新进行位置的选择。

 说明：理论上应该使用一个8x8的二维数组表示棋盘，但实际上可以通过算法使用一个吻一维数组解决问题： arr[8] = {0, 4, 7, 5, 2, 6, 1, 3},因为每行只有一个皇后

3.2 代码示例

public class EightQueen {

    // 先定义一个数表示共有多少个皇后
    int max = 8;
    // 并定义一个数组，存放皇后位置
    int[] array = new int[max];
    public static void main(String[] args){
       EightQueen queen =  new EightQueen();
       queen.check(0);
    }


    // 编写一个方法 放置皇后
    public void check(int n){
        if (n == max){ // n = 8,表示第0 - 7 个皇后已经放好了, 打印， 作为退出递归的条件
            print();
            return;
        }

        // 依次放入皇后并判断是否冲突
        for(int i = 0; i < max ; i ++){
            // 先把要放置的皇后放到该行的第一列
            array[n] = i;
            //判断是否冲突
            if(judge(n)){  // 不冲突 ， 接着放第n + 1 个皇后
                check(n + 1);
            }else{  // 冲突，退回到 上一层： array[n] 后移，也就是 i++

            }
        }
    }

    // 放置第n个皇后时，判断放置位置是否冲突
    public boolean judge(int n){  // n 表示第n + 1个皇后 , n取值为 0 - 7， 一共有八个皇后
        for(int i = 0; i < n; i++){  // 是否跟已经放置的皇后位置冲突: 同一列 和 同一 斜线 ： 斜率为1
            if(array[i] == array[n] || Math.abs(n - i) == Math.abs(array[n] - array[i])){
                return false;
            }
        }
        // 如果都不冲突， 说明可以放在这
        return true;

    }


    // 写一个方法 打印皇后位置
    public void print(){
        for (int i = 0; i < array.length; i++){
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }