本文介绍了递归的概念，强调了递归必须有明确的终止条件和子问题的简化。递归在解决数学问题（如阶乘、八皇后、迷宫问题）、算法（如快排、归并、二分查找）等方面有广泛应用。同时，文章提醒在使用递归时要注意避免死递归和栈溢出，通过回溯法解决八皇后问题作为实例进行说明。
递归是什么？
说白了，递归就是不断调用自身一个过程。
上代码最好说！
public static int factorial(int n) {
// 终止条件
if (n == 1) {
return 1;
}
// 调用自己，处理子问题factorial(n-1)
return factorial(n - 1) * n;
}
如上代码是一个求n的阶乘的实现，使用了递归，代码运行过程中会不断调用自己，直到遇到终止条件。
- 构成递归需要具备一定条件：
- 子问题须与原始问题为同样的事，且更为简单。
- 递归必须要有一个出口，即终止条件,不能无限制的调用下去。
有什么用？
1.可以解决各种数学问题，如：八皇后问题，汉诺塔、阶乘、迷宫问题、求和篮子问题等。
2.各种算法都可能用到递归，如：快排、归并、二分查找、分治算法等。
3.将使用栈解决的问题转化到使用递归来解决，更简洁。
使用递归的注意事项
1.递归必须向退出递归的条件逼近（子问题越来越小，不是越来越大），否则会出现死递归，即死循环，最后导致栈溢出。
2.当一个方法执行完毕，或遇到return，就会返回结果，遵守谁调用该方法就会将结果返回给谁，返回到调用该方法的方法继续执行的过程叫回溯。
下面使用递归来解决一些问题
一、迷宫问题：给定一个地图（网格，用二维数组表示），给定起点和终点，找出一条从起点到终点的路径。
代码实现：
import java.util.Random;
/**
* @author chenzhiyuan
* @date 2019-09-01 16:17
*/
public class Maze {
public static void main(String[] args) {
int[][] map = createMap(10, 10);
// 设置一些障碍
map[3][1] = 1;
map[3][2] = 1;
map[3][3] = 1;
map[5][4] = 1;
map[4][5] = 1;
map[8][4] = 1;
printMap(map);
boolean hasWay = findWay(map, 1, 1, 8, 8);
System.out.println("是否找到了路：" + hasWay);
printMap(map);
}
/**
* 使用递归回溯找路
* 约定找路策略：下->右->上->左，即先往下走，走不通往右，右走不通往上，上走不通往左。如果改变找路的策略，会找到不同的路径。
* 0表示没有走过， 1表示该位置为墙，2表示走过且可以走通，3 表示走过但走不通，
*
* @param map 地图
* @param startX 起点的x坐标
* @param startY 起点的y坐标
* @param endX 终点的x坐标
* @param endY 终点的y坐标
* @return 返回是否找到了路
*/
public static boolean findWay(int[][] map, int startX, int startY, int endX, int endY) {
if (map[endX][endY] == 2) {
// 终点为2时表示找到了路径
return true;
} else {
if (map[startX][startY] == 0) {
// 将该位置置为2，表示该位置已走过
map[startX][startY] = 2;
if (findWay(map, startX + 1, startY, endX, endY)) {// 往下
return true;
} else if (findWay(map, startX, startY + 1, endX, endY)) {// 往右
return true;
} else if (findWay(map, startX - 1, startY, endX, endY)) {// 往上
return true;
} else if (findWay(map, startX, startY - 1, endX, endY)) {// 往左
return true;
} else {
// 上下左右都走了走不通，说明该位置是个死胡同，用3表示
map[startX][startY] = 3;
return false;
}
} else {
// map[startX][startY] 为1或2或3时，直接返回false
return false;
}
}
}
/**
* 创建一个i行j列的地图，地图的四个边框都置为1，代表墙
*/
public static int[][] createMap(int i, int j) {
int[][] map = new int[i][j];
for (int row = 0; row < i; row++) {
map[row][0] = 1;
map[row][j - 1] = 1;
}
for (int col = 0; col < j; col++) {
map[0][col] = 1;
map[i - 1][col] = 1;
}
return map;
}
/**
* 打印地图
*/
public static void printMap(int[][] map) {
for (int i = 0; i < map.length; i++) {
for (int j = 0; j < map[0].length; j++) {
System.out.print(map[i][j] + "\t");
}
System.out.println();
}
}
}
输出：
1 1 1 1 1 1 1 1 1 1
1 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 1
1 1 1 1 0 0 0 0 0 1
1 0 0 0 0 1 0 0 0 1
1 0 0 0 1 0 0 0 0 1
1 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 1
1 0 0 0 1 0 0 0 0 1
1 1 1 1 1 1 1 1 1 1
是否找到了路：true
1 1 1 1 1 1 1 1 1 1
1 2 0 0 0 0 0 0 0 1
1 2 2 2 2 0 0 0 0 1
1 1 1 1 2 0 0 0 0 1
1 3 3 2 2 1 0 0 0 1
1 3 3 2 1 0 0 0 0 1
1 3 3 2 0 0 0 0 0 1
1 3 3 2 2 2 0 0 0 1
1 3 3 3 1 2 2 2 2 1
1 1 1 1 1 1 1 1 1 1
这里先抛出一个问题：怎么求最短路径，在后面的文章中我会回过来解决这个问题。
二、八皇后问题：在一个8x8的国际象棋行摆放8个皇后，使其不能回想攻击，即任意的两个皇后不能处于同一行同一列或同一斜线上面，问有多少中摆法。
解决思路（回溯法）：
1.第一个皇后先放在第一行第一列
2.第二个皇后放在第二行第一列，判断是否ok，如果不ok，继续放在第二列、第三列…直到找到一个合适的位置。
3.第二个皇后找到一个合适位置后，继续放第三个皇后，还是从第一列开始放，直到第三个皇后找到一个合适的位置；第三个皇后找到一个合适位置后继续放低四个皇后。。。直到第八个皇后找到一个合适的位置，就算是得到一个解。
4.第八个皇后会遍历完第8行，然后回第七个皇后找位置的方法栈，开始回溯。
5.当回到放第一个皇后的那个方法栈，至此将得到第一个皇后放在第一行第一列的所有解。
6.接着把第一个皇后放在第一行第二列，递归执行1,2,3,4的步骤。
代码实现：
/**
* @author chenzhiyuan
* @date 2019-09-01 20:26
*/
public class Queen8 {
// 皇后问题的解法数量
private static int count;
// 皇后数量
private static int num = 8;
// 用于存放皇后的位置
// 例如[0,4,7,5,2,6,1,3]表示皇后分别在[0,0]、[1,4]、[2,7]、[3,5]。。。的位置
private static int[] location = new int[num];
public static void main(String[] args) {
findLocation(0);
}
/**
* 为皇后们找位置
*
* @param n 第n个皇后
*/
public static void findLocation(int n) {
// 终止条件，第一个皇后的序号是0，所有当n==num时已经是第9个皇后了，此时打印皇后位置并终止
if (n == num) {
System.out.println("------------第" + (++count) + "种------------");
prindQueenLocation();
return;
}
// 每个皇后可选位置有8个，因此每个位置皇后们都要尝试一下
for (int i = 0; i < num; i++) {
// 第n个皇后尝试第i个位置
location[n] = i;
// 判断该位置是否合理，如果合理，请下一位皇后尝试选择位置
if (judge(n)) {
findLocation(n + 1);
}
// 如果不合理，当前（第n个）皇后继续尝试下一个位置
}
}
/**
* 判断第n个皇后和之前的n-1个皇后是否在同一列或在同一斜线上
*
* @param n 第n个皇后
*/
public static boolean judge(int n) {
for (int i = 0; i < n; i++) {
// 是否在同一列
boolean b1 = location[i] == location[n];
// 是否在同一斜线上，假设两个位置的坐标为（x1,y1）,(x2,y2)
// 因为斜线的斜率为1，那么（x1-x2）== (y1-y2)
boolean b2 = Math.abs(n - i) == Math.abs(location[n] - location[i]);
if (b1 || b2) {
return false;
}
}
return true;
}
/**
* 输入皇后们的位置
*/
public static void prindQueenLocation() {
// 创建一个二维数组表示棋盘，并初始化每个位置为○
String[][] array = new String[num][num];
for (int i = 0; i < num; i++) {
for (int j = 0; j < num; j++) {
array[i][j] = "○";
}
}
// 根据location选定皇后们的位置
for (int i = 0; i < location.length; i++) {
array[i][location[i]] = "●";
}
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[0].length; j++) {
System.out.print(array[i][j] + "\t");
}
System.out.println();
}
}
}
如下是部分解法，一共92种：
------------第1种------------
● ○ ○ ○ ○ ○ ○ ○
○ ○ ○ ○ ● ○ ○ ○
○ ○ ○ ○ ○ ○ ○ ●
○ ○ ○ ○ ○ ● ○ ○
○ ○ ● ○ ○ ○ ○ ○
○ ○ ○ ○ ○ ○ ● ○
○ ● ○ ○ ○ ○ ○ ○
○ ○ ○ ● ○ ○ ○ ○
------------第2种------------
● ○ ○ ○ ○ ○ ○ ○
○ ○ ○ ○ ○ ● ○ ○
○ ○ ○ ○ ○ ○ ○ ●
○ ○ ● ○ ○ ○ ○ ○
○ ○ ○ ○ ○ ○ ● ○
○ ○ ○ ● ○ ○ ○ ○
○ ● ○ ○ ○ ○ ○ ○
○ ○ ○ ○ ● ○ ○ ○
...
------------第92种------------
○ ○ ○ ○ ○ ○ ○ ●
○ ○ ○ ● ○ ○ ○ ○
● ○ ○ ○ ○ ○ ○ ○
○ ○ ● ○ ○ ○ ○ ○
○ ○ ○ ○ ○ ● ○ ○
○ ● ○ ○ ○ ○ ○ ○
○ ○ ○ ○ ○ ○ ● ○
○ ○ ○ ○ ● ○ ○ ○
最重要的两点还是递归出口和回溯，用递归时一定要先找到递归的结束条件，然后将问题拆分成稍小一点的问题，递归解决小问题，并不断逼近递归出口，解决了小问题后会返回上次触发递归的方法栈进行回溯，并最终得到答案。
扫一扫
366
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
