Java遞歸尋路實作，你了解遞歸了嗎

哈喽！小夥伴們，好久不見，是不是談遞歸色變，遞歸遞歸：通俗講，我們拆分一下，“遞”出去，“歸”回來，哈哈，正如狂鐵所說：“越是困難越是要戰勝它”，不如來看看這篇文章，對于小白可能會有新的收獲，大牛的話就小kiss了，好，廢話不多說，準備好了嗎？學習一下基礎知識後，我們就來玩起來吧！！！💦

文章目錄

• • 引
  • 使用遞歸計算階乘
  • 地圖建立
  • 核心
  • 完整代碼

引

看懂這張圖，方法調用方法，棧開新棧，遞歸尾結束要回到main棧，必須一級一級傳回，每一次傳回都是調用整個方法，調用完成棧被釋放，直至回到棧底main遞歸結束并能夠自己畫出來，了解遞歸的運作機制，這是我手畫的，不好看，你的呢，還不動起來😏

🆗，到這，如果上面的你都了解了，那麼我相信你可以用遞歸寫出 計算 n 的階乘的程式了，什麼，寫不出，沒有關系，我來補上，一定要了解在棧裡運作機制

使用遞歸計算階乘

public class Factorial {
    public static void main(String[] args) {
        Factorial  jie = new Factorial ();
        System.out.println(jie.f(3));
    }
    public int f(int n){
        if(n == 1){
            return 1;
        }else {
            return n*f(n-1);
        }
    }
}
           

接下來就可以玩起來了，一個有趣的迷宮問題，假設有如下二維數組表示地圖，數字1表示圍牆，數字0表示可以走，現在有隻小老鼠被困在下标為

[1][1]

的位置，出口在下标為

[6][5]

的位置，思考：使用遞歸如何讓小老鼠尋路逃生呢？

思考過後，腦袋是不是蒙蒙的，不是？那請你喝瓶雪花❄😂

想要玩起來

地圖建立

思路

1. 先建立迷宮，用二維數組表示 int[][] map = new int[8][7];
    2. 規定 map：0 表示可以走，1表示牆不能走
           

1，列印二維數組

public class miGong {
    public static void main(String[] args) {
       
        int[][] map = new int[8][7];
 
        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();
        }
    }
}
           

2，規定牆和可以走的，隻需要通過周遊指定行和列，再把兩個特别的單獨強調，完成

for (int i = 0;i < 7;i++){
    map[0][i] = 1;
    map[7][i] = 1;
}
for (int i = 0;i < 8;i++){
    map[i][0] = 1;
    map[i][6] = 1;
}
map[3][1] = 1;
map[3][2] = 1;
           

實作效果：

核心

這時就完成了地圖，思考如何使用遞歸尋路呢

開始吧，寫一個方法，通過遞歸來實作尋路，我直接放代碼了

• 首先，建立一個類，寫

  findWay

  方法，傳回值是

  boolean

  ，三個參數，分别是地圖，二維坐标

  x，y

  用來确定位置
• 接着，我們判斷如果

  map[6][5] == 2

  ，就認為小老鼠找到出口了，這點很重要，它是遞歸回調條件
• 如果

  map[6][5] == 2

  條件為假，說明小老鼠沒有找到出口，調用方法時初始化開始坐标，接着

  map[i][j] = 2;

  假設可以走通就把坐标的值修改為2，表示老鼠走的痕迹
• 接下來，奇妙的事情發生了，遞歸就在這裡開始了，我們調用自己

  findWay

  傳入參數，我們先确定下來小老鼠的行走軌迹，假設是

  下-右-上-左

  ，我們通過修改數組下标來表示小老鼠的移動，假設上下左右都沒能走通，就把坐标值修改為3，表示小老鼠被困死了，傳回false，失敗，🆗，代碼已經完成
• 小夥伴：什麼？？？完成了？？？

class way{

    //使用遞歸回溯的思想來解決
    public boolean findWay(int[][] map,int i,int j){
       if(map[6][5] == 2){
           return true;
       }else{
           if(map[i][j] == 0){
               //假定可以走通
               map[i][j] = 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 {
                   map[i][j] = 3;
                   return false;
               }
           }else {
               return false;
           }
       }
    }
}
           

主函數調用，檢視結果：

way f = new way();
        f.findWay(map,1,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();
        }
           

運作代碼檢視結果：

看到成功尋路逃生~~~，是不是還很疑惑

一定要了解透，你也可以設定死路，隻要上面的了解了，達到能在腦子裡快速回放遞歸的過程，棧開棧，棧銷毀，等等，你就可以随便玩了，之前是不是一直不了解為什麼說遞歸占用空間，謹慎使用，這下就明明白白了，好了，多了解了解，這就是所有内容，感受到遞歸的魅力了嗎？哈哈 是不是很好玩，體會這種思想，感謝觀看

完整代碼

public class miGong {
    public static void main(String[] args) {
        //思路
        //1.先建立迷宮，用二維數組表示 int[][] map = new int[8][7];
        //2.規定 map：0 表示可以走，1表示牆不能走
        int[][] map = new int[8][7];
        for (int i = 0;i < 7;i++){
            map[0][i] = 1;
            map[7][i] = 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 < map.length; i++) {
            for (int j = 0; j < map[i].length; j++) {
                System.out.print(map[i][j]+" ");
            }
            System.out.println();
        }
        way f = new way();
        f.findWay(map,1,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();
        }
    }
}

class way{

    //使用遞歸回溯的思想來解決
    public boolean findWay(int[][] map,int i,int j){
       if(map[6][5] == 2){
           return true;
       }else{
           if(map[i][j] == 0){
               //假定可以走通
               map[i][j] = 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 {
                   map[i][j] = 3;
                   return false;
               }
           }else {
               return false;
           }
       }
    }
}