Java递归图文详解及解决迷宫回溯问题、八皇后问题

最新推荐文章于 2023-07-22 17:13:30 发布

梅川库紫

最新推荐文章于 2023-07-22 17:13:30 发布

阅读量638

点赞数 1

分类专栏： java 数据结构文章标签： java 数据结构算法

本文链接：https://blog.csdn.net/qq_54836465/article/details/126955356

版权

java 同时被 2 个专栏收录

8 篇文章 0 订阅

订阅专栏

数据结构

1 篇文章 0 订阅

订阅专栏

递归的概念

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

递归调用机制

public class Recursion {
    public static void main(String[] args) {
        test(4);
    }
    public static void test(int n){
        if(n > 2){
            test(n - 1);
        }
        System.out.println("n = " + n);
    }
}

以上是递归的一个简单的案例，在 test 方法中调用 test 方法，运行原理如下所示：

当程序执行到主方法 main 中，java首先会在栈中开辟一个独立的空间，并在其中调用了 test 方法。

当调用 test 方法后，程序又会在栈中开辟一个新的独立空间，即新的栈帧。其中传入了一个局部变量 n = 4。在执行 test 方法时，判断 n 是否大于2，成立后，又调用了 test 方法。

之后重复上述操作。值得注意的是，虽然每次调用 test 方法都传入了一个变量 n，但由于每次调用 test 方法所产生的数据空间（栈帧）是独立的，因此每次传入的 n 作为一个局部变量，仅在当前方法有效。

当执行到 n = 2时，不再调用 test 方法，进而往下执行输出语句 “ n = 2 ”。

在 test(2) 执行完毕之后，它所在的数据空间就会被摧毁，即被pop出去，下一个数据空间就会顶上来，按照栈先进后出的原理，接下来应该按顺序执行 test(3)，test(4)。

因此控制台输出的是：

以上就是对递归过程的初步解析，接下来用递归解决迷宫回溯问题。

迷宫回溯问题

求小球从起点走向终点的最短路径，其中红色格子为墙，不可走。

说明

1)小球得到的路径，和程序员设置的找路策略有关即:找路的上下左右的顺序相关。

2)再得到小球路径时，可以先使用(下右上左)，再改成(上右下左)，看看路径是不是有变化。

3)测试回溯现象。

4)思考:如何求出最短路径?

用代码绘制迷宫

通过二维数组来模拟迷宫，1表示墙，0表示可走的路。

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;
        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 表示从地图的哪个位置开始出发 (1,1)。

3. 如果小球能到 map[6][5] 位置，则说明通路找到。

4. 约定：当map[i][j] 为 0 表示该点没有走过当为 1 表示墙； 2 表示通路可以走； 3 表示该点已经走过，但是走不通。

5. 在走迷宫时，需要确定一个策略(方法) 下->右->上->左 , 如果该点走不通，再回溯。

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

最后整合，使用递归回溯给小球找路并输出新的地图。

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

输出结果

八皇后问题

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

八皇后问题算法思路分析

1) 第一个皇后先放第一行第一列。

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

3)继续第三个皇后，还是第一列、第二列……直到第8个皇后也能放在一个不冲突的位置，算是找到了一个正确解。

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

5)然后回头继续第一个皇后放第二列，后面继续循环执行 1.2.3.4的步骤。

说明

理论上应该创建一个二维数组来表示棋盘，但是实际上可以通过算法用一个一维数组即可解决问题。

例如：arr[8] = {0,4,7,5,2,6,1,3}，arr 的下标表示第几行，即第几个皇后。

而 arr[ i ] = val，val 表示第 i+1 个皇后，放在第 i+1行的第 val+1 列。

代码实现

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;
	static int judgeCount = 0;
	public static void main(String[] args) {
		//测试一把 ， 8皇后是否正确
		Queue8 queue8 = new Queue8();
		queue8.check(0);
		System.out.printf("一共有%d解法", count);
		System.out.printf("一共判断冲突的次数%d次", judgeCount); // 1.5w
		
	}
	
	
	
	//编写一个方法，放置第n个皇后
	//特别注意： check 是 每一次递归时，进入到check中都有  for(int i = 0; i < max; i++)，因此会有回溯
	private void check(int n) {
		if(n == max) {  //n = 8 , 其实8个皇后就既然放好
			print();
			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) {
		judgeCount++;
		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皇后是否在同一斜线
			// n = 1  放置第 2列 1 n = 1 array[1] = 1
			// Math.abs(1-0) == 1  Math.abs(array[n] - array[i]) = Math.abs(1-0) = 1
			//3. 判断是否在同一行, 没有必要，n 每次都在递增
			if(array[i] == array[n] || Math.abs(n-i) == Math.abs(array[n] - array[i]) ) {
				return false;
			}
		}
		return true;
	}
	
	//写一个方法，可以将皇后摆放的位置输出
	private void print() {
		count++;
		for (int i = 0; i < array.length; i++) {
			System.out.print(array[i] + " ");
		}
		System.out.println();
	}

}