08-java算法学习之三（递归和八皇后问题）

事莫待来时忍，欲莫待动时防。即来思隐，即动思防，如火炽水溢，障之甚难。—曾国藩

讲到递归，我脑子里就会想起菲波纳契数列和迷宫游戏。要是让你在下面这样的迷宫中，去找到一条能顺利从入口到出口的线路，你可能要几分钟，但是如果编写一个程序，只要你一执行，它就能马上给你答案。你可能要问，到底怎么回事呢？仿佛说来说去，都不知道递归是什么。那到底递归是什么呢？

！一.什么是递归？

递归指的是一个过程：函数不断引用自身，直到引用的对象已知。
例如：假设n>1且n为正整数，并符合f(n)=f(n-1)+1,f(1)=1。现在求f(5)的值。

看完图片，你应该有了对递归的一些理解。总结一下，递归就是：一层一层的去找，直到找到那个未知数是已知数，然后将这个已知数赋值给未知数，再一层一层的返回，这就是递归的整个过程。

！二.迷宫中的递归

迷宫中的递归，其实是和上面一样的意思，我们看上面的递归，最后找到有值的未知数，才能层层返回，最后得到答案。那有没有可能，没有这样有值的未知数呢？迷宫的递归就是这么来的，我们探寻走出迷宫的道路，如果是一条“死胡同”，那我们需要回滚，然后走其他的路

！三.代码实现迷宫

1. 用数组构建一个迷宫，假设 0是可以走的路 1是墙 2是走得通的路 3是走了但走不通的路。

//8行6列
	static int X=8;
	static int Y=6;
	int[][] map=new int[X][Y];
		//上下
		for(int i=0;i<Y;i++) {
			map[0][i]=1;
			map[X-1][i]=1;
		}
		//左右
		for (int j = 0; j <X; j++) {
			map[j][0]=1;
			map[j][Y-1]=1;
		}
		map[3][1]=1;
		map[3][2]=1;
		map[4][3]=1;
		map[5][5]=1;

2. 打印这个迷宫，如下图所示。

	//打印
		for (int i = 0; i < X; i++) {
			for (int j = 0; j < Y; j++) {
				System.out.print(map[i][j]+" ");
			}
			System.out.println();
		}

3. 创建一个判断是否走得通路的函数

	//下--->右--->上--->左
	public static boolean Recurtion(int[][] map, int i, int j) {
		if (map[X - 2][Y - 2] == 2) {
			return true;
		} else {
			if (map[i][j] == 0) {
				map[i][j] = 2;
				if (Recurtion(map, i + 1, j)) {
					return true;
				} else if (Recurtion(map, i, j + 1)) {
					return true;
				} else if (Recurtion(map, i - 1, j)) {
					return true;
				} else if (Recurtion(map, i, j - 1)) {
					return true;
				} else {
					// 上面上下左右都不行，就只有将这个位置置3，代表死路
					map[i][j] = 3;
					return false;
				}
			} else {
				return false;
			}
		}
	}

4.运用上面所示的递归，我们可以得到以下所示走出迷宫的路线图。

!!八皇后问题？

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

！！一.八皇后问题分析

1. 假设我们是一行一行打印的。
2. 那么我们就不用担心在同一行，而只需要担心是否在同一列或者是对角线。
3. 如果出现后面第n行开始无论怎么放都不符合条件，那么我们就需要运用递归的思想，回溯到上一级。
4. 这样不断回溯，直到第八行放下后，所有的皇后都不相互“攻击”，则为成功。

！！二.八皇后问题代码实现。

package 八皇后问题;

public class Queue8 {
	int Max=8;//八个皇后
	static int Count=0;//计数
	int[] arry=new int[Max];
	public static void main(String[] args) {
		//	new Queue8().Check(0);其中Check(0)代表从第一个开始检测
		new Queue8().Check(0);
		//统计合格种数 92种
		System.out.println("一共有"+Count+"种");
	}
	//主要检查入口
	private void Check(int n) {
		//n=Max代表一行全部检测完毕
		if(n==Max) {
			print();
			return;
		}
		for (int i = 0; i < Max; i++) {
			arry[n]=i;
			if(Judge(n)) {
				Check(n+1);
			}
		}
	}
	//打印一行的数据
	private void print() {
		Count++;
		for (int i = 0; i < Max; i++) {
			System.out.print(arry[i]+" ");
		}
		System.out.println();
		
	}

	//判断是否同一列(arry[i]==arry[n])或者在对角线(Math.abs(n-i)==Math.abs(arry[n]-arry[i]))
	private boolean Judge(int n) {
		for (int i = 0; i < n; i++) {
			if((arry[i]==arry[n])||(Math.abs(n-i)==Math.abs(arry[n]-arry[i]))) {
				return false;
			}
		}
		return true;
	}
}

总结。

可能你会发现，迷宫和八皇后问题用的是回溯，那么递归和回溯有什么区别呢？递归是一种数据结构，而回溯是一种思想，而这种思想能用递归来实现。回溯算法实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。回溯算法和递归紧密的联系，而递归和栈有紧密关联，递归可以说是不断出栈和入栈的。