一:递归的概念
简单的说:递归就是方法自己调用自己,每次调用时传入不同的变量,递归有助于编程者解决复杂的问题,同时可以让代码变得简洁.
- 打印问题
- 阶乘问题
二:递归调用的规则
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;
}}
三:递归需要遵守的重要规则
- 执行一个方法时,就创建一个新的受保护的独立空间(栈空间)
- 方法的局部变量是独立的,不会相互影响
- 如果方法中使用的时引用类型的变量(数组)就会共享该引用类型的数据
- 递归方法必须向退出递归的条件逼近,否则就是无限递归,然后出现Stack Overflow的情况
- 当一个方法执行完毕,或者遇到了return,就会返回,遵守谁调用,就将结果返回给谁,同时当方法执行完毕或者返回的时,该方法也就执行完毕
迷宫问题代码:
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个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。
八皇后解题思路:
- 将第一个皇后放在第一行的第一列
- 将第二个皇后放在第二行的第一列,判断是否可行,如果不可行的话,继续放在第二列,第三列,依次将所有的列都放完,直到找到一个合适的
- 继续放第三个皇后,还是第一列,第二列…知道第八个皇后也能放在一个不冲突的位置,就算是找到了一个正确的解法
- 当得到一个正确解法的时候,栈回到上一个栈的时候就会开始回溯,即:将第一个皇后放在第一列的所有正确解.全部得到
- 然后回头继续将第一个皇后放到第二列,后面继续循环执行1,2,3,4的步骤
说明:理论上应该创建一个二维数组来表示棋盘,但是实际上通过算法,用一个一维数组即可解决问题,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 <max ; 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();
}
}
代码运行演示:
这里总结一下,关于八皇后的解题思路:
首先:
- 在代码中我们一共定义了三个方法,judge,check,print.
- judge是为了判断在8*8的中放置的皇后位置,是否会和这个皇后之前已经放置好的皇后,从横竖斜线上是否会冲突.方法中有一个for循环:
for (int i = 0; i < n; i++)
解释一下:假如说我放的这个皇后是第5个.那么这个这个循环就会依次从第一个皇后(横竖斜线)开始判断,知道第4个皇后判断完毕后,再return出去 - 重点就是这个check方法.里面用了一种很重要的算法,叫回溯.
首先解释一下代码:
if (n == max) {//n=8,其实就是八个皇后就已经放好了
print();
return;
}
这个就是判断是否八个皇后是否摆放完毕.
//依次放入皇后,并判断没有冲突
for (int i = 0; i <max ; 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),依次推下去.
    这里有一个回溯的步骤,我们看看代码运行的结果:
假如说我们在第一次得到[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,在循环倒数第一个数字,也就是第八行.依次类推.不断的进行递归,知道找出所有符合条件的位置.
扫一扫
1800
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
