【递归】
递归重要规则
1．执行一个方法时，就创建一个新的受保护的独立空间(栈空间)
-
方法的局部变量是独立的，不会相互影响,比如n变量
-
如果方法中使用的是引用类型变量(比如数组，对象)，就会共享该引用类型的数据.
-
递归必须向退出递归的条件逼近，否则就是无限递归,出现栈溢出（StackOverflowError)
-
当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕。
演示
public class Recursion01{
public static void main(String[] agrs){
T t1 = new T();
t1.test(4);
int res = t1.factorial(5);
System.out.println("res="+res);
}
}
class T {
/*
每次递归调用后会在栈中生成一个新的空间
当条件不满足之后，从栈顶往下返回值，每次返回都会把方法体的代码（在这里是"打印n"）都执行一遍
所以最后的执行结果是
n = 2
n = 3
n = 4
*/
public void test(int n){
if(n > 2){
test(n - 1);
}
System.out.println("n="+n);
}
//factorial 阶乘
/*
*/
public int factorial(int n) {
if (n == 1) {
return 1;
}else {
return factorial(n - 1) * n;
}
}
}
练习
习题一 给出对应位置的斐波那契数
请使用递归的方式求出斐波那契数1,1,2,3,5,8,13.….给你一个整数n，求出它的值是多少？
思路：
1.当n=1斐波那契数是1
2.当n=2斐波那契数是1
3.当n>=3斐波那契数是前两个数的和
4.这里就是一个递归的思想
public class RecursionExercise01{
public static void main(String[] agrs){
T t1 = new T();
int n = 7;
int res = t1.fibonacci(n);
if(res ! = -1){
System.out.println("n="+ n +" 对应的斐波那契数=" + res);
}
}
}
class T {
public int fibonacci(int n){
//若不满足条件，则这两个数肯定是1，直接返回即可
if(n >= 1){
if(n == 1 || n == 2){
return 1;
}else{//当n>=3斐波那契数是前两个数的和，思想有点类似阶乘问题
return fibonacci(n-1) + fibonacci(n-2);
}
}else {
System.out.println("输入的整数n需要大于等于1");
return -1;
}
}
}
习题二 逆推思想与递归（猴子吃桃问题）
猴子吃桃子问题
有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个1以后每天猴子都吃其中的一半，然后再多吃一个。
当到第10天时，想再吃时(即还没吃)发现只有1个桃子了。
问题:最初共多少个桃子?(即第一天有多少桃子)
思路 逆推
1. day = 10时有1个桃子
2. day = 9时有(day10 + 1)* 2 = 4
3. day = 8时有(day9 + 1)* 2 = 10
4. 规律就是，前一天的桃子=(后一天的桃子+1)*2
5. 递归
public class RecursionExercise01{
public static void main(String[] agrs){
T t1 = new T();
// int n = 7;
// int res = t1.fibonacci(n);
// if(res != -1){
// System.out.println("n="+ n +" 对应的斐波那契数=" + res);
// }
//桃子
int day = 9;
int peachNum = t1.peach(day);
if(peachNum != -1){
System.out.println("第"+day+"天有"+ peachNum +"个桃子");
}
}
}
class T {
public int peach(int day){
if(day == 10){//第10天只有1个桃子
return 1;
}else if(day >= 1 && day <= 9){//规律要自己寻找
return(peach(day + 1)+1) * 2;
}else {
System.out.println("day的范围是1~10");
return -1;
}
}
}
习题三 递归与回溯机制（老鼠走迷宫）
老鼠走迷宫
有一个迷宫（即一个正方形二维数组map[] []），其中使用1代表边界障碍
右下角为迷宫出口(假设为map[6] [5])
找出走到出口的路线
解法
public class MiGong{
public static void main(String[] agrs){
//思路
//1．先创建迷宫，用二维数组表示
//2．先规定map数组的元素值:0表示可以走1表示障碍物
int[][] map = new int[8][7];
//3．将最上面的一行和最下面的一行,全部设置为1
for(int i = 0; i< 7; i++){
map[0][i]= 1;
map[7][i]= 1;
}
//4.将最右面的一列和最左面的一列全部置为1
for(int i = 0; i< 7; i++){
map[i][0]= 1;
map[i][6]= 1;
}
//单独设置障碍物
map[3][1] = 1;
map[3][2] = 1;
//测试回溯机制
map[2][2] = 1;
//输出当前地图
System.out.println("=====当前地图情况=====");
for(int i = 0; i<map.length;i++){
for(int j = 0; j<map[i].length; j++){
System.out.print(map[i][j] + " ");
}
System.out.println("");
}
//使用findWay给老鼠找路
T t1 = new T();
t1.findWay(map, 1, 1);//初始位置1,1
// t1.findWay2(map, 1, 1);//初始位置1,1
System.out.println("\n=====找路的情况=====");
for(int i = 0; i<map.length;i++){
for(int j = 0; j<map[i].length; j++){
System.out.print(map[i][j] + " ");
}
System.out.println("");
}
}
}
class T{
// 使用递归回溯的思想来解决老鼠出迷宫
//1. findway方法就是专内来找出迷宫的路径
//2. 如果找到，就返回true ,否则返回false
//3. map就是二维数组,即表示迷宫
//4. i,j就是老鼠的位置,初始化的位置为(1,1)
//5．因为我们是递归的找路，所以我先规定 map数组的各个值的含义
// 0表示可以走1表示障碍物2表示可以走 3表示走过，但是走不通是死路
//6．当map[6][5] = 2就说明找到通路,就可以结束，否则就继续找-
//7．先确定老鼠找路策略下->右->上->左
public boolean findWay(int[][] map, int i, int j){
//关键点1：递归退出条件
if(map[6][5] == 2){//说明找到出路
return true;
}else {
if(map[i][j] == 0){//当前这个位置0，说明可以走
//那么可以给当前位置一个假定值2（假设可以走通）
map[i][j] = 2;
//关键点2：寻路策略
//然后根据找路策略来确定该位置是否真的可以走通
//下->右->上->左
if(findWay(map, i + 1, j)){//下
return true;
}else if(findWay(map, i, j + 1)){//右
return true;
}else if (findWay(map, i - 1, j)) {//上
return true;
}else if (findWay(map, i, j - 1)) {//左
return true;
}else {
//所有方向都走不通那说明最开始的假设是错的
//那么把当前位置赋值为3并返回false
map[i][j] = 3;
return false;
}
}else {//不为0就只有三种情况，1,2,3
return false;
}
}
}
//改变寻路策略，下右上左->上右下左
public boolean findWay2(int[][] map, int i, int j){
//关键点1：递归退出条件
if(map[6][5] == 2){//说明找到出路
return true;
}else {
if(map[i][j] == 0){//当前这个位置0，说明可以走
//那么可以给当前位置一个假定值2（假设可以走通）
map[i][j] = 2;
//关键点2：寻路策略
//然后根据找路策略来确定该位置是否真的可以走通
//下->右->上->左
if(findWay2(map, i - 1, j)){//上
return true;
}else if(findWay2(map, i, j + 1)){//右
return true;
}else if (findWay2(map, i + 1, j)) {//上
return true;
}else if (findWay2(map, i, j - 1)) {//左
return true;
}else {
//所有方向都走不通那说明最开始的假设是错的
//那么把当前位置赋值为3并返回false
map[i][j] = 3;
return false;
}
}else {//不为0就只有三种情况，1,2,3
return false;
}
}
}
}
注意点：
所谓的“回溯机制”，就是递归条件达成之后，栈从最顶端往后返回值的过程实现的
在这个问题中体现为，如果“老鼠”走出下一步之后，判定上下左右均不可走，那么会把当前位置标注为3，即不可走
然后会回到上一步的位置，接着判断下一个位置是否能走（因为上一个位置只是选中了一个可以走的方向，其他的还没有判断）
习题四 汉诺塔
汉诺塔问题
即有三个柱子，第一个柱子上有一些从大到小往上摞的圆盘
现在需要将这些圆盘全部移动到最右边的柱子上，过程中要求大圆盘不能在小圆盘之上
思路
实际上我们可以把问题简化成最基本的两种情况：
①若只有一个块需要移动，那么只需要将其从a移动到c即可
②若有两个块需要移动，那么需要先将最上面的块移动到b，用b作为过渡存放最上面的块，
然后将最下面的块移动到c并将b的块也移动至c即可
然后无论是之后需要移动多少个块，我们都可以将其简化为上述两种基本类型
使用递归的方法，对移动个数每次减一，不断开辟新的栈，直到将其简化为基本类型
完成基本类型的计算后再不断的返回值到下一个栈即可实现目标
public class HanoiTower{
public static void main(String[] agrs){
Tower tower = new Tower();
tower.move(2, 'A', 'B', 'C');
}
}
class Tower{
//方法
//num 表示要移动的个数，a, b, c 分别表示A塔、B塔、C塔
public void move(int num, char a, char b, char c){
//只有一个盘的情况
if(num == 1){
System.out.println(a+"->"+c);
}else {
//若有多个盘，可以看成两个，即最下面的和上面的所有盘
//1.先移动上面所有的盘到b，借助c
move(num - 1, a, c, b);
//2.把最下面的这个盘移动到c
System.out.println(a+"->"+c);
//3.再把b塔的所有盘移动到c，借助a
move(num - 1, b, a, c);
}
}
}
注意点：我们只是给出移动的步骤，而无需考虑盘子本身
标签：复健,03,Java,递归,map,int,else,return,public From： https://www.cnblogs.com/DAYceng/p/16772381.html