Java数据结构与算法-递归（迷宫，八皇后问题）代码及实现过程

递归

1. 递归的概念
2. 递归的条件
3. 递归遵循的规则
4. 递归的应用场景
5. 迷宫代码实现
6. 八皇后代码实现
7. 分析与总结

一，递归的概念

• 就是自己调用自己，每次调用传入不同的参数，或者说就是把规模比较大的问题划分为子问题进行解决，并且和原问题具有相同的解决方法，解决重复性操作，简化代码量。

二，递归的条件

• 1，通过递归可以划分成小规模的问题，且新问题和原问题有一样的解决方法。
• 2，必须得有递归出口，不能无限进行递归。

三，递归得规则

• 1，执行一个方法得时候就会创建一个新的受保护的空间（栈空间）
• 2，方法的局部变量是相互独立的，不会相互影响，比如n
• 3,如果方法中是引用类型变量（比如数组），就会共享该引用类型的数据
• 4，递归必须向退出递归的条件逼近，否则就是无限递归,出现StackOverflowError)
• 5，当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕

四，递归的引用场景

• 1，各种数学问题如:8皇后问题,汉诺塔,阶乘问题,迷宫问题,球和篮子的问题(google编程大赛)
• 2，各种算法中也会使用到递归，比如快排，归并排序，二分查找，分治算法等.
• 3，将用栈解决的问题–>第归代码比较简洁

五，迷宫问题

• 找到一条可以到出口的路
  
  原理：可以使用回溯算法进行解决
  思路：
  • 1，使用递归回溯来给小球找路
  • 2，i,j表示从地图的哪个位置开始出发(1,1)
  • 3，如果小球能到map[6][5]位置，则说明通路找到.
  • 4，约定：当map[i][j]为0表示该点没有走过当为1表示墙；2表示通路可以走；3表示该点已经走过，但是走不通
  • 5，在走迷宫时，需要确定一个策略(方法)下->右->上->左,如果该点走不通，再回溯。

代码实现：

package com.atxiaopeng.digui;

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; 
		}
		//设置挡板,1表示墙壁
		map[3][1] = 1;
		map[3][2] = 1;
		map[3][3] = 1;
		map[2][3] = 1;
		//map[1][3] = 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();
		}
		//使用递归回溯给小球找路
		//setWay1(map,1,1);
		setWay2(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();
		}
		
		
	}	
	public static boolean setWay1(int[][]map,int i,int j){
		if(map[6][5]==2){
			//通路已经找到
			return true;
		}else{
			if(map[i][j]==0){
				//如果当前这个点还没有走过
				//按照策略下->右->上->左走
				map[i][j]=2;//假定该点是可以走通.
				if(setWay1(map,i+1,j)){
					//向下走
					return true;
				}else if(setWay1(map,i,j+1)){
					//向右走
					return true;
				}else if(setWay1(map,i-1,j)){
					//向上
					return true;
				}else if(setWay1(map,i,j-1)){
					//向左走
					return true;
				}else{
					//说明该点是走不通，是死路
					map[i][j]=3;
					return false;
					}
			}else{
				//如果map[i][j]!=0,可能是1，2，3
				return false;
			}
	
		}
	}
	public static boolean setWay2(int[][]map,int i,int j){
		if(map[6][5]==2){
			//通路已经找到
			return true;
		}else{
			if(map[i][j]==0){
				//如果当前这个点还没有走过
				//按照策略下->右->上->左走
				map[i][j]=2;//假定该点是可以走通.
				if(setWay2(map,i-1,j)){
					//向上走
					return true;
				}else if(setWay2(map,i,j+1)){
					//向右走
					return true;
				}else if(setWay2(map,i+1,j)){
					//向下
					return true;
				}else if(setWay2(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格的国际象棋上摆放八个皇后，使其不能互相攻击，即：任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法**(92)**。
  
• 思路：
  1，第一个皇后先放第一行第一列。
  2，第二个皇后放在第二行第一列、然后判断是否OK，如果不OK，继续放在第二列、第三列、依次把所有列都放完，找到一个合适。
  3，继续第三个皇后，还是第一列、第二列…直到第8个皇后也能放在一个不冲突的位置，算是找到了一个正确解。
  4，当得到一个正确解时，在栈回退到上一个栈时，就会开始回溯，即将第一个皇后，放到第一列的所有正确解，全部得到。
  5，然后回头继续第一个皇后放第二列，后面继续循环执行1,2,3,4的步骤。
• 代码实现
• 理论上要用二维数组来进行模拟，但是发现一维数组也可以进行模拟，刚好一维数组 arr[i] = value的下标i可以表示：第i+1个皇后，同时可以表示i+1行，数组的值value+1可以表示第几列。

package com.atxiaopeng.digui;

public class King8 {
	
	//定义一个max表示共有多少个皇后
	int max = 8;
	//定义一个数组arr，保存皇后放置后的位置结果，比如{0，4，7，2，6，1，3}
	int[] arr = new int[max];
	static int count = 0;
	static int judgecount = 0;	
	
	public static void main(String[] args) {
		
		King8 king8 = new King8();
		king8.check(0);
		System.out.println("一共有："+count);
		System.out.println("一共判断了次数："+judgecount);
		
	}
	//依次添加第n个皇后
	private void check(int n) {
		if (n == max) {
			show();
			return;
		}
		for (int i = 0; i < max; i++) {
			//从第一列的位置开始，每一个皇后都会从第一列的位置开始进行比较
			//回溯可以理解为不管成不成功，每个皇后它都要执行一遍从第一列到最后一列的放置。
			arr[n] = i;
			if (judge(n)) {
				check(n+1);
			}
	
		}
		
	}
	
	private boolean judge(int n) {
		//判断次数
		judgecount++;
		for (int i = 0; i < n; i++) {
			//arr[i] == arr[n]说明在同一列
			//n-i的绝对值==arr[n]-arr[i]说明在对角线上
			if (arr[i]==arr[n]||Math.abs(n-i) == Math.abs(arr[n]-arr[i])) {
				return false;
			}
		}
		return true;
		
	}
	//打印每一种排法
	private void show() {
		count++;
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i]+" ");
		}
		System.out.println();
	}
	

}

• 打印的结果
  
  
  截取了部分结果，总共有92种排法，由此可见比较的次数还是很多的，回溯的效率不高。

欢迎指正，共同进步！