数据结构与算法---递归实现

递归应用场景

看个实际应用场景，迷宫问题(回溯)，递归(Recursion)

递归的概念

简单的说: 递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂的问题,同时可以让代码变得简洁。

递归调用机制

我列举两个小案例,来帮助大家理解递归，部分学员已经学习过递归了，这里在给大家回顾一下递归调用机制

打印问题
阶乘问题
使用图解方式说明了递归的调用机制

代码演示

package com.xuge.recursion;
 
/**
 * author: yjx
 * Date :2022/5/2913:07
 **/
public class RecursionTest {
  public static void main(String[] args) {
// TODO Auto-generated method stub
//通过打印问题，回顾递归调用机制
//test(4);
 
 
    int res = factorial(3); System.out.println("res=" + res);
  }
//打印问题.
 
 
  public static void test(int n) { if (n > 2) {
    test(n - 1);
  } //else {
    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
  }
  }
}

递归能解决什么样的问题

递归用于解决什么样的问题

各种数学问题如: 8 皇后问题 , 汉诺塔, 阶乘问题, 迷宫问题, 球和篮子的问题(google 编程大赛)
各种算法中也会使用到递归，比如快排，归并排序，二分查找，分治算法等.
将用栈解决的问题-->第归代码比较简洁

递归需要遵守的重要规则

执行一个方法时，就创建一个新的受保护的独立空间(栈空间)
方法的局部变量是独立的，不会相互影响, 比如 n 变量
如果方法中使用的是引用类型变量(比如数组)，就会共享该引用类型的数据.
递归必须向退出递归的条件逼近，否则就是无限递归,出现 StackOverflowError，死龟了:)
当一个方法执行完毕，或者遇到 return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕

递归-迷宫问题

迷宫问题

代码实现:

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

package com.xuge.recursion;
 
/**
 * author: yjx
 * Date :2022/5/2914:02
 **/
public class MiGong {
  public static void main(String[] args) {
    //1.创建一个二维数组
    int[][] arr = new int[8][7];
    //2.使用1表示墙，上下全部置为1
    for (int i = 0; i < 7; i++) {
      arr[0][i] = 1;
      arr[7][i] = 1;
    }
    //左右全部置为1
    for (int i = 0; i < 8; i++) {
      arr[i][0] = 1;
      arr[i][6] = 1;
    }
    //输出地图
    //设置挡板
    arr[3][1] = 1;
    arr[3][2] = 1;
    System.out.println("=============地图的情况=============");
    for (int i = 0; i < 8; i++) {
      for (int j = 0; j < 7; j++) {
        System.out.print(arr[i][j] + "\t");
      }
      System.out.println();
    }
 
 
    System.out.println("============使用递归回溯============");
    setWay(arr, 1, 1);
    for (int i = 0; i < 8; i++) {
      for (int j = 0; j < 7; j++) {
        System.out.print(arr[i][j] + "\t");
      }
      System.out.println();
    }
 
    System.out.println("=============\"注意策略会改变数组内容=============");
    System.out.println("============使用递归策略2回溯============");
    setWay2(arr, 1, 1);
    for (int i = 0; i < 8; i++) {
      for (int j = 0; j < 7; j++) {
        System.out.print(arr[i][j] + "\t");
      }
      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   从哪个位置开始找 (i,j)
   * @return 如何找到通路，就返回ture
   */
  public static Boolean setWay(int[][] map, int i, int j) {
       if(map[6][5]==2){//表示找到通路
         return true;
       }else{
         if(map[i][j]==0){//还要走
           //确定一个策略(方法) 下->右->上->左
           //1.认为map可以走通
           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]=1,2,3
           return false;
         }
       }
  }
 
  //上-右-下-左
  public static Boolean setWay2(int[][] map, int i, int j) {
    if(map[6][5]==2){//表示找到通路
      return true;
    }else{
      if(map[i][j]==0){//还要走
        //上-右-下-左
        //1.认为map可以走通
        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]=1,2,3
        return false;
      }
    }
  }
}