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循环中。

只绘制两个级别的呼叫可以帮助澄清。您将在第一个“级别”（递归的根调用）中找到，for循环只是按照您的预期迭代，但是它将散布在它所做的递归调用的处理中（每个都创建一个递归的“下一级”）。

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

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

1 个答案: