递归的应用场景
迷宫回溯问题
简单的说:递归就是方法自己调用自己,每次调用时传入不同的变量,递归有助于编程者解决复杂的问题,同时可以让代码变得简洁
递归调用机制
1.当程序执行到一个方法时,就会开辟一个独立的空间(栈)
2.每个空间的数据(局部变量)是独立的
1.打印问题和2,阶乘问题
package com.atguigu.recursion;
public class RecursionTest {
public static void main(String[] args) {
//通过打印问题,我们回顾一下递归的调用机制
test(4);
}
public static void test(int n){
if(n>2){
test(n-1);
}
System.out.println("n:"+n);
}
//阶乘问题
public static int factorial(int n){
if(n==1){
return 1;
}else { //传入3
return factorial(n-1)*n;//factorial(2)*3
}
}
}
递归能解决什么样的问题
1.各种数学问题,8皇后,汉诺塔,阶乘问题,迷宫问题,球和篮子问题…
2.各种算法中也会用到递归,比如快排,归并排序,二分查找,分治算法等
3,将用栈解决的委托—>递归代码比较简洁
递归需要遵循的重要规则
1,执行一个方法的时候,就会创建一个新的受保护的独立空间(栈空间)
2.方法中的局部变量是独立的,不会相互影响,比如上面打印问题的n
(但是如果方法中使用的是引用类型的变量,就会共享该引用类型的数据)
3,递归必须向退出递归的条件的逼近,否则就是无限递归了,就会成为一个死递归.
4,当一个方法执行完毕后,或者遇到return就会返回,遵守谁调用,就将结果放回给谁,同时方法执行网吧或者返回时,该方法也就执行完毕.
递归的实际应用案例,迷宫问题
package com.atguigu.recursion;
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;
}
//设置挡板
map[3][1]=1;
map[3][2]=1;
//输出地图
for(int i=0;i<8;i++){
for (int j=0;j<7;j++){
System.out.print(map[i][j]+"\t");
}
System.out.println();
}
//使用递归回溯给小球找路
setWay(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]+"\t");
}
System.out.println();
}
}
//使用递归回溯来个小球找路
/**
* 说明:
* 1.map表示地图
* 2.i.j表示从哪个位置开始从地图哪个位置开始出发(1,1)
* 3,如果小球能到map[6][5]的位置,则通路找到
* 4,约定:当map的ij为0时,表示改点没有走过,当为1时表示墙,如果wei2,表示是一个通路可以走
* 如果为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 setWay1(int[][] map,int i,int j){
if(map[6][5]==2){//说明通路已经找到,直接退出
return true;
}else {
//想看这个路有没有走过
if(map[i][j]==0){//如果当前这个点还没有走过
//按照策略走先下->右->上->左
map[i][j]=2;//假定改点可以走通
if(setWay1(map,i-1,j)){//向上走
return true;
}else if(setWay1(map,i,j+1)){//向右走
return true;
}else if(setWay1(map,i+1,j)){//向下走
return true;
}else if(setWay1(map,i,j-1)){//向左走
return true;
}else {
//说明改点是走不通的,是死路
map[i][j]=3;
return false;
}
}else {//如果map[i][j]!=0,可能是1,2,3
return false;
}
}
}
用一个数组表示我们不同的策略,然后用一个for循环把每个策略走一遍,得到的结果进行统计,看看数组中有几个2,最少的那个就是最短的路径.
八皇后问题(回溯算法)
八皇后是一个古老而著名的问题,是回溯算法的典型案例:在8x8格的国际象棋上摆放八个皇后,使其不能相互攻击,即:任意两个皇后都不能处于同一行,或同一列或同一斜线上,问有多少种摆法
八皇后问题算法分析
1,把第一个皇后先放到第一行第一列
2,把第二个皇后放到第二行第一列,然后判断是否ok,如果不ok,继续放在第二列,第三列,依次把所有列都放完,找到一个合适的ok.
3,继续第三个皇后,还是第一列,第二列…知道第八个皇后也能放在一个不冲突的位置,算是找到一个正确的解
4.当得到一个正确的解时,在栈退回到上一个栈时,就会开始回溯,即将第一个皇后,放到第一列的所有正确解,全部得到
5.然后回头继续第一个皇后放到第一行的第二列,后面继续循环执行1,2,3,4的步骤,看看八皇后问题有多少个解
说明
理论上应该创建一个二维数组来表示棋盘,但是实际上可以通过算法,用一个一维数组即可解决问题.arr[8]={0,4,7,5,2,6,1,3}//对应arr下标表示第几行,即第几个皇后,arr[i]=val表示第i+1个皇后,放在第i+1行的第var+1列
package com.atguigu.recursion;
public class Queue8 {
//定义一个max表示共有的多少个皇后
int max=8;
//定义一个数组,保存皇后放置位置的结果
//比如arr={0,4,7,5,2,6,1,3}
int[] array=new int[max];
public static void main(String[] args) {
//测试一把,八皇后是否正确
Queue8 queue8 = new Queue8();
queue8.check(0);//放第一皇后,放第一行第一列
}
//编写一个方法,放置第n个皇后
//特备注意,check是每一次递归时,进入到check中都有一套for循环
private void check(int n){
if(n==max){//n=8 其实我们在放第九个皇后,因为我们从0开始,前面8个放好了
print();
return;
}
//依次放入皇后,并判断是否冲突
for (int i=0;i<max;i++){
//先把第n个皇后,放到改行的第一列
array[n]=i;
//判断当放置第n个皇后到i列是是否冲突
if(judeg(n)){//不冲突
//接着放n+1个皇后
check(n+1);//开始递归
}
//就是这里,一旦冲突,我们就开始回溯算法,回到上一步,
//就继续执行array[n]=i;即将第n个皇后,放置在本行得到后移的一个位置
//我们的每一次check都会调用回溯,递归开始里面就已经有回溯了.
}
}
//查看当我们放置第n个皇后时,就去检测该皇后是否和前面已经摆放的皇后冲突
/**
*
* @param n 表示方的第n个皇后
* @return
*/
private boolean judeg(int n){
for (int i=0;i<n;i++) {
//说明:array[i]==array[n]第n个皇后是否前面的n-1个皇后是否在同一列
//array[n]||Math.abs(n-i)==Math.abs(array[n]-array[i])表示判断第n个皇后是否和第i个皇后在同一斜线
//Math.abs().取绝对值
//这里我们没有必要判断是否在同一行,因为我们的n在递增
if (array[i] == array[n] || Math.abs(n - i) == Math.abs(array[n] - array[i])) {
return false;
}
}
return true;
}
//写一个方法,可以将皇后最后摆放的位置打印出来
private void print(){
for (int i=0;i<array.length;i++){
System.out.print(array[i]+" \t");
}
System.out.println();
}
}
但是我们这里其实回溯算法是比较慢的,因为就这个八皇后问题,我们递归调用了一万多次,所有我们后面还有其他的算法来进行优化,
2676
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
