Java用棧簡單實現迷宮

迷宮

用0表示可以走，1表示不可以走，從左上角走到右下角，能否找到一條路，如果找到，那麼打印出來路徑，用2表示走過的路徑

如果找不到，那麼圖中嘗試過的點置爲 -1.

程序運行如下

輸出如下

我的主要思路，首先用一個Maze類來表示迷宮上面的點，類中包含點的橫縱座標和點的值，用棧保存迷宮路徑。從入口到出口，依次按照右 下 左 上判斷四周是否是通路，如果是，將判斷的點入棧，並將值置爲2，如果四周都沒有通路，那麼當前點出棧，將值置爲-1.
成功的條件是到達終點（即右下角的點），
失敗的條件是:
       1.開始值不是0
       2.棧爲空，表示沒有路徑。

實現的完整代碼

Maze.java代碼

public class Maze {
    private int x;
    private int y;
    private int value;

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    public Maze(){

    }
    public Maze(int x,int y,int value){
        this.x = x;
        this.y = y;
        this.value = value;
    }
    public int getValue() {
        return value;
    }
    public void setValue(int value) {
        this.value = value;
    }
}

這裏我沒有用jdk提供的棧，自己學着寫了一個簡單的棧。

MyStack.java代碼

public class MyStack {
    private final static int MAXSIZE = 10;
    private int top;
    private Maze[] mazes;

    public Maze getMazes(int i) {
        return mazes[i];
    }

    public void setMazes(Maze[] mazes) {
        this.mazes = mazes;
    }

    public int getTop() {
        return top;
    }

    public void setTop(int top) {
        this.top = top;
    }

    public MyStack(){
        top = -1;               //棧首下標
        mazes = new Maze[MAXSIZE];
    }
    //判棧空
    public boolean isEmpty(){
        if (top == -1){
            return true;
        }
        return false;
    }
    //棧溢出
    public boolean isFull(){
        if (top == MAXSIZE){
            return true;
        }
        return false;
    }
    //出棧
    public void pop(){
        top--;
    }
    //入棧
    public void push(Maze maze){
        top++;
        mazes[top] = maze;
    }

    public void printStack(){
        for (int i=0;i<=top;i++){
            System.out.println("("+mazes[i].getX()+","+mazes[i].getY()+")");
        }
    }
}

用MazeGame類表示一個迷宮，來保存所有的點，start()方法開始找入口，如果入口也就是（0，0）點不是0，那麼沒有路徑，輸出no way.否則表示可以進入，將（0，0）點入棧。road方法是主要實現代碼，首先判棧空，如果棧是空的，那麼表示沒有可以走通的路徑，用temp保存當前棧頂元素。startX，startY保存當前的橫縱座標。
       如果棧不空，判斷當前迷宮點是否是終點，是終點遊戲結束。不是終點開始判斷是否有路徑可以走，如果沒有，該迷宮點出棧，用-1表示當前點已經走過。如果有，按照右 下 左 上的順序依次判斷，可以走，將該迷宮點入棧。

MazeGame.java代碼

public class MazeGame {
    private Maze[][] mazes;
    public MazeGame(Maze[][] mazes){
        this.mazes = mazes;
    }

    public void start(){
        int startX = 0;
        int startY = 0;
        MyStack stack = new MyStack();
        mazeGamePrint();
        if (mazes[startX][startY].getValue() == 0){              // 入口是否爲0
            stack.push(mazes[startX][startY]);
            mazes[startX][startY].setValue(2);                  //將以走過的路徑置爲2
        }else{
            System.out.println("no way");
            return ;
        }
        if(road(stack)){
            stack.printStack();
            mazeGamePrint();
        }else{
            System.out.println("no way！");
            mazeGamePrint();
        }
    }

    private boolean road(MyStack stack) {
        while(!stack.isEmpty()){
            int temp = stack.getTop();                              //棧頂元素
            int startX = stack.getMazes(temp).getX();
            int startY = stack.getMazes(temp).getY();
            if (startX == mazes.length-1 && startY == mazes[0].length-1){       //到達終點
                System.out.println("路徑走過的座標");
                return true;
            }else if (hasRoad(stack,startX,startY)){                                              //沒有到達終點 且有路可走
                if(startY<mazes[0].length-1 && mazes[startX][startY+1].getValue() == 0){       //向右
                stack.push(mazes[startX][startY+1]);
                mazes[startX][startY+1].setValue(2);
                } else if (startX < mazes.length-1 && mazes[startX+1][startY].getValue() == 0){       //向下
                    stack.push(mazes[startX+1][startY]);
                    mazes[startX+1][startY].setValue(2);
                }else if (startY > 0 && mazes[startX][startY-1].getValue() == 0){       //向左
                    stack.push(mazes[startX][startY-1]);
                    mazes[startX][startY-1].setValue(2);
                } else if (startX > 0 && mazes[startX-1][startY].getValue() == 0){   //向上
                    stack.push(mazes[startX-1][startY]);
                    mazes[startX-1][startY].setValue(2);
                }
            }else{
                stack.pop();
                mazes[startX][startY].setValue(-1);
            }
        }
        return false;
    }

    private boolean hasRoad(MyStack stack,int startX,int startY) {
        if (startY<mazes[0].length-1 && mazes[startX][startY+1].getValue() == 0 ||
                startX < mazes.length-1 && mazes[startX+1][startY].getValue() == 0 ||
                startX > 0 && mazes[startX-1][startY].getValue() == 0 ||
                startY > 0 && mazes[startX][startY-1].getValue() == 0){
            return true;
        }
        return false;
    }

    public void mazeGamePrint(){
        for (int i=0;i<mazes.length;i++){
            for (int j=0;j<mazes[0].length;j++){
                System.out.print(mazes[i][j].getValue()+" ");
            }
            System.out.println();
        }
    }
}

測試代碼Test.java

public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("請輸入迷宮的行列數（m * n）:");
        int m = scanner.nextInt();
        int n = scanner.nextInt();
        Maze[][] mazes = new Maze[m][n];
        System.out.println("請輸入迷宮的路徑");
        for (int i=0;i<m;i++){
            for (int j=0;j<n;j++){
                mazes[i][j] = new Maze(i,j,scanner.nextInt());
            }
        }
        /*Maze[][] mazes = new Maze[][]{
                {new Maze(0,0,0),new Maze(0,1,1),new Maze(0,2,0)},
                {new Maze(1,0,0),new Maze(1,1,0),new Maze(1,2,0)},
                {new Maze(2,0,1),new Maze(2,1,0),new Maze(2,2,0)}
        };*/
        MazeGame mazeGame = new MazeGame(mazes);
        mazeGame.start();
    }
}