数据结构与算法【Java】04---递归
目录
前言
数据 data 结构(structure)是一门 研究组织数据方式的学科，有了编程语言也就有了数据结构.学好数据结构才可以编写出更加漂亮,更加有效率的代码。
- 要学习好数据结构就要多多考虑如何将生活中遇到的问题,用程序去实现解决.
- 程序 = 数据结构 + 算法
- 数据结构是算法的基础, 换言之，想要学好算法，需要把数据结构学到位
我会用数据结构与算法【Java】这一系列的博客记录自己的学习过程，如有遗留和错误欢迎大家提出，我会第一时间改正！！！
注：数据结构与算法【Java】这一系列的博客参考于B站尚硅谷的视频，文章仅用于学习交流，视频原地址为【尚硅谷】数据结构与算法（Java数据结构与算法），大家记得一键三连哦~
上一篇文章数据结构与算法【Java】03---栈
接下来进入正题!
1、概念
1.1、递归
递归就是方法自己调用自己,每次调用时 传入不同的变量，递归有助于编程者解决复杂的问题,同时可以让代码变得简洁
1.2、递归能解决什么问题
- 各种数学问题如: 8 皇后问题 , 汉诺塔, 阶乘问题, 迷宫问题, 球和篮子的问题
- 各种算法中也会使用到递归，比如快排，归并排序，二分查找，分治算法等
- 将用栈解决的问题-->递归代码比较简洁
1.3、递归要遵守的重要规则
- 执行一个方法时，就创建一个新的受保护的独立空间(栈空间)
- 方法的局部变量是独立的，不会相互影响, 比如 n 变量
- 如果方法中使用的是引用类型变量(比如数组)，就会共享该引用类型的数据.
- 递归 必须向退出递归的条件逼近，否则就是无限递归,出现 StackOverflowError，死归了:)
- 当一个方法执行完毕，或者遇到 return，就会返回， 遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕
2、递归调用机制
我们用两个例子来了解一下递归调用机制
- 打印问题
- 阶乘问题
-
代码演示
public class RecursionTest { public static void main(String[] args) { //通过打印问题，了解递归调用机制 test(4); System.out.println("====================="); int res = factorial(5); System.out.println("res=" + res); } //打印问题. public static void test(int n) { if (n > 2) { test(n - 1); } //else {//加入else只有n = 2 System.out.println("n=" + n); // } } //阶乘问题 public static int factorial(int n) { if (n == 1) { return 1; } else { return factorial(n - 1) * n; // 1 * 2 * 3 } } } -
结果及分析
（1）结果
（2） 结果分析
3、迷宫问题
3.1、问题描述
红色代表围墙，小球不能通过，小球从左上角开始移动，移动到右下角结束
提示：
map表示地图i,j表示从地图的哪个位置开始出发 (1,1)- 如果小球能到
map[6][5]位置，则说明通路找到. - 约定： 当
map[i][j]为 0 表示该点没有走过 当为 1 表示墙 ； 2 表示通路可以走 ； 3 表示该点已经走过，但是走不通 - 在走迷宫时，需要确定一个策略(方法) 例如：下->右->上->左 , 如果该点走不通，再回溯
3.2、代码实现
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;
}
//设置挡板，1都表示不能走
map[3][1] = 1;
map[3][2] = 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();//输出一行之后再换行
}
//使用递归回溯来给小球找路
//setWay(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();//输出一行之后再换行
}
}
//使用递归回溯来给小球找路
//说明
//1. map 表示地图
//2. i,j 表示从地图的哪个位置开始出发 (1,1)
//3. 如果小球能到 map[6][5] 位置，则说明通路找到.
//4. 约定： 当map[i][j] 为 0 表示该点没有走过 当为 1 表示墙 ； 2 表示通路可以走 ； 3 表示该点已经走过，但是走不通
//5. 在走迷宫时，需要确定一个策略(方法) 下->右->上->左 , 如果该点走不通，再回溯
/**
*
* @param map 表示地图
* @param i 从哪个位置开始找
* @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 static boolean setWay2(int[][] map, int i, int j) {
if(map[6][5] == 2) { // 通路已经找到ok
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;
}
}
}
}
结果展示
（1）策略1setWay()下右上左
（2）策略2setWay2()上右下左
3.3、问题分析
1.小球得到的路径，和我们设置的 找路策略有关即：找路的上下左右的顺序相关
- 再得到小球路径时，可以先使用(下右上左)，再改成( 上右下左)，看看路径是不是有变化
- 测试回溯现象
- 思考: 如何求出最短路径? 思路-》代码实现.
4、八皇后问题
4.1、问题描述
八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于
1848 年提出：在 8×8 格的国际象棋上摆放八个皇后，使其不能互相攻击，即： 任意两个皇后都不能处于同一行 、
同一列或同一斜线上，问有多少种摆法(92)。
4.2、思路分析
-
第一个皇后先放第一行第一列
-
第二个皇后放在第二行第一列、然后判断是否 OK， 如果不 OK，继续放在第二列、第三列、依次把所有列都放完，找到一个合适
-
继续第三个皇后，还是第一列、第二列……直到第 8 个皇后也能放在一个不冲突的位置，算是找到了一个正确解
-
当得到一个正确解时，在栈回退到上一个栈时，就会开始回溯，即将第一个皇后，放到第一列的所有正确解，全部得到.
-
然后回头继续第一个皇后放第二列，后面继续循环执行 1,2,3,4 的步骤
-
示意图:
-
说明：理论上应该创建一个二维数组来表示棋盘，但是实际上可以通过算法，用一个一维数组即可解决问题. arr[8] =
-
比如arr[8] ={0 , 4, 7, 5, 2, 6, 1, 3} 中5表示第4个皇后放在第4行第5列
-
对应 arr 下标 表示第几行，即第几个皇后，arr[i] = val , val 表示第 i+1 个皇后，放在第 i+1行的第 val+1 列
-
4.3、代码实现
public class Queen8 {
//定义一个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) {
//测试
Queen8 queen8 = new Queen8();
queen8.check(0);
System.out.println("解法一共有："+count+"种");
System.out.println("一共判断冲突："+judgeCount+"次");
}
//编写一个方法，放置第n个皇后
//注意：check是每一次递归时，进入到check中都有for循环，因此会有回溯
private void check(int n){
if(n == max){//8个皇后已经放好了
print();
return;
}
//依次放入皇后并判断是否冲突
for (int i = 0; i < max; i++) {
//先把当前的皇后放到该行的第一列
array[n] = i;
//判断当放置第n个皇后到i列时，是否冲突
if(judge(n)){//不冲突
//接着放第n+1个皇后，即开始递归
check(n+1);
}
//如果冲突，就继续执行 array[n] = i; 即将第n个皇后，放置在本行得 后移的一个位置(i++)
}
}
//查看当我们放置第n个皇后，就去检测该皇后是否和前面已经摆放的皇后冲突
//n表示第n个皇后
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();
}
}
- 结果展示
到这里关于递归的两个典型的问题就结束了，但是关于递归解决的问题还有很多，需要大家仔细思考每个问题中的递归调用和回溯，欢迎大家提出问题！！！
