在这个示例代码中，回溯发生在哪里？

Question

package maze;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;

public class Maze {


    public static void main(String[] args) {
        int board[][] = new int[31][121];
        Random rand = new Random();
        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j < board[0].length; j++) {
                board[i][j]=1;
            }
        }
        int r = rand.nextInt(board.length);
        while(r%2==0){
            r=rand.nextInt(board.length);
        }

        int c = rand.nextInt(board[0].length);
        while(c%2==0){
            c=rand.nextInt(21);
        }
        System.out.format("r is %d and c is %d\n",r,c);
        board[r][c]=0;
        recursion(r,c,board);
        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j < board[0].length; j++) {
                if (board[i][j]==1) {
                    System.out.print("#");
                } else if (board[i][j]==0) {
                    System.out.print(" ");
                }

            }
            System.out.println("");
        }

    }
    public static void recursion(int r, int c,int[][] board){
        ArrayList<Integer> randDirections = generateDirections();
        int[] randDir=new int[randDirections.size()];

        for (int i = 0; i < randDir.length; i++) {
            randDir[i]=randDirections.get(i);
            System.out.println(randDir[i]);
        }

        for (int i = 0; i < randDir.length; i++) {

            switch(randDir[i]){
                case 1:
                    //checks up position
                    if (r-2>=0) {
                        if (board[r-2][c]!=0) {
                            board[r-2][c] = 0;
                            board[r-1][c] = 0;
                            recursion(r - 2, c,board);
                        }
                    }
                    break;
                case 2:
                    //checks right position
                    if (c + 2 <= board[0].length - 1){
                        if (board[r][c + 2] != 0) {
                            board[r][c + 2] = 0;
                            board[r][c + 1] = 0;
                            recursion(r, c + 2,board);
                        }
                    }
                    break;
                case 3:
                    //checks down position
                    if (r + 2 <= board.length - 1){
                        if (board[r + 2][c] != 0) {
                            board[r+2][c] = 0;
                            board[r+1][c] = 0;
                            recursion(r + 2, c,board);
                        }
                    }
                    break;
                case 4:
                    //checks left position
                    if (c - 2 >= 0){
                        if (board[r][c - 2] != 0) {
                            board[r][c - 2] = 0;
                            board[r][c - 1] = 0;
                            recursion(r, c - 2,board);
                        }
                    }
                    break;
            }  
        }
    }
    public static ArrayList<Integer> generateDirections(){
        ArrayList<Integer> randoms = new ArrayList();
        for (int i = 0; i < 4; i++) {
            randoms.add(i+1);
        }
        Collections.shuffle(randoms);
        return randoms;
    }
}

我可以看到，当我的程序无法为我的迷宫开辟另一条路径时，我的程序正在回溯，并且我的递归方法只有在它一直回溯到第一个路径方格时才会停止。但是，我不知道到底是在做什么。在我看来，当四个随机方向的 for 循环用尽时，该方法应该停止。有人可以向我解释哪部分代码导致它回溯以及它是如何工作的吗？

Answer 1

答案在于调用堆栈并了解堆栈的每一级发生了什么。当一个递归调用耗尽它的 for 循环时，就会发生“回溯”，在此之后，该方法返回，从堆栈中弹出一个级别，并继续进行调用的堆栈级别上下文的 for 循环。

仅列出 2 个级别的调用有助于澄清。您会发现在第一个“级别”（递归的根调用）中，for 循环只是按照您的预期进行迭代，但是它会穿插在它进行的递归调用的处理中（每个都创建一个“下一级”递归）。

调用栈底层的for循环遍历所有迭代，而上一层的for循环可能只在第一次迭代。