一:递归的概念
简单的说:递归就是方法自己调用自己,每次调用时传入不同的变量,递归有助于编程者解决复杂的问题,同时可以让代码变得简洁.
1.当程序执行到一个方法时,就会开辟一个独立的空间(栈)
然后执行到了test(3)不会直接执行结果,而是继续的开辟一个新的栈
…
这个时候的if条件不成立,再出来执行输出语句,由于在n=2时才执行输出,然后执行n=2执行完了后,n=2的栈就没了,然后再执行n=3的栈,同理一直向下执行,直到主方法执行完毕之后,直接退出程序.
假如说:
加入了else,是这种的话:n=2会输出,其他的栈else不会被执行.
阶乘代码:
public static int factorial(int n) {
if (n == 1) {
return 1;
} else {
return factorial(n - 1) * n;
}}
三:递归需要遵守的重要规则
迷宫问题代码:
package com.qiu.recursion;
public class MiGong {
public static void main(String[] args) {
//先创建一个二维数组,模拟迷宫
int[][] map =new int[8][7];
//使用1表示墙
//上下置为1
System.out.println("输出的地图为:");
map[3][1] =1;
map[3][2] = 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;
}
for (int i = 0; i <8 ; i++) {
for (int j = 0; j < 7; j++) {
System.out.print(map[i][j]+" ");
}
System.out.println();
}
System.out.println("小球走过的路的标识");
//使用递归回溯给小球找路
setWay(map,1,1);
//输出新的地图,小球走过,并标识过的路
for (int i = 0; i <8 ; i++) {
for (int j = 0; j < 7; j++) {
System.out.print(map[i][j]+" ");
}
System.out.println();
}
}
/**
*
* @param map 表示地图
* @param i 从那个位置开始找
* @param j
* @return 如果找到通路就返回true
*/
//使用递归回溯给小球找路
//说明:map表示地图
//2.i,j表示从地图的哪一个位置开始出发
//3.如果小球能到map的[6][5]则说明通路找到
//4.约定:当map[i][j]为0时宝石路没走过,为1卫视墙,2表示通路可以走,3表示该路已经走过,走不通
//5.在走迷宫时需要确定一个策略(方法) 下右上左
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;
}
}
}
}
八皇后问题(英文:Eight queens),是由国际西洋棋棋手马克斯·贝瑟尔于1848年提出的问题,是回溯算法的典型案例。问题表述为:在8×8格的国际象棋上摆放8个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行、同一列或同一斜线上,问有多少种摆法。
八皇后解题思路:
说明:理论上应该创建一个二维数组来表示棋盘,但是实际上通过算法,用一个一维数组即可解决问题,arr[8] = {0,4,7,5,2,6,1,3}//对应arr下标,表示第几行,即第几个皇后,arr[i] =val,val表示第i+1个皇后,放在第i+1行的第val+1列
代码演示:
package com.qiu.recursion;
public class Queue8 {
//定义一个max表示共有多少个皇后
int max = 8;
//定义一个数组array,保存皇后放置的结果
int[] array = new int[max];
static int count = 0;
public static void main(String[] args) {
//测试一把,八皇后是否正确.
Queue8 queue8 = new Queue8();
queue8.check(0);
System.out.printf("一共有%d种解法",count);
}
//编写一个方法,放置第n个皇后
//特别注意:check是每一次递归时,进入到check都有for (int i = 0; i
private void check(int n) {
//
if (n == max) {
//n=8,其实就是八个皇后就已经放好了
print();
return;
}
//依次放入皇后,并判断没有冲突
for (int i = 0; i <max ; i++) {
//先把当前的这个皇后,放到该行的第一列
array[n] =i;//假如说,i=0然后array[1] = 0,
//判断当放置第n个皇后到i列时,是否冲突
if (judge(n)){
//不冲突,接着放n+1个皇后,即开始递归
check(n+1);
}
//如果冲突了,就继续执行array[n] = i;即将第n个皇后,放置到本行的后一个位置
}
}
//查看当我们放置第n个皇后之后,就去检测该皇后是否和前面已经摆放的皇后冲突
private boolean judge(int n){
for (int i = 0; i < n; i++) {
//array[i] == array[n]:假设这个i和n相等,那他们处于同一列,第n个皇后是否和前面的n-1个皇后在同一列
//Math.abs(n-i) == Math.abs(array[n]-array[i]:表示判断第N个皇后是够和第i个皇后是否在同一条斜线
//Math.abs() 返回参数的绝对值
//判断是否在同一行,没有必要.因为i每次都在递增,不会放在同一行
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();
}
}
代码运行演示:
这里总结一下,关于八皇后的解题思路:
首先:
if (n == max) {
//n=8,其实就是八个皇后就已经放好了
print();
return;
}
这个就是判断是否八个皇后是否摆放完毕.
//依次放入皇后,并判断没有冲突
for (int i = 0; i
这个循环是为了依次摆放好第一个第二个第…个,直到第8个
//先把当前的这个皇后,放到该行的第一列
array[n] =i;//假如说,i=0然后array[0] = 0,
解释:我们在第一次放的第一皇后的时候,将这第一个皇后放置到第n =0行第i=0列,也就是第一行第一列,然后进行判断,这个第一行第一列前面放置的皇后的位置是否跟这个放置的皇后位置冲突.事实上,我们才放了第一个,所以说这里不会进行这个if判断.
接着i = 1也就是需要在第一行的第二列放置第二个皇后,显然这个皇后是不符合要求的,代码中进行到if判断,judge判断为false,故执行方法check(1).也就是在第2行第1列放置皇后(array[1] = 0),依次推下去.
这里有一个回溯的步骤,我们看看代码运行的结果:
![在这里插入图片描述](https://img-blog.csdnimg.cn/2020091519260074.png#pic_center)
假如说我们在第一次得到[0,4,7,5,2,6,1,3]时,接下回溯验证[0,4,7,5,2,6,1,4]-[0,4,7,5,2,6,1,7]
然后再回溯到上一行也就是数组的倒数第二个数字,图中数字为1,接下来就循环到2,在循环倒数第一个数字,也就是第八行.依次类推.不断的进行递归,知道找出所有符合条件的位置.