用Java完成迷宫(运用栈)

题目如图片：

处理的办法及代码：

1、迷宫中每个元素，有值、行、列，用一个类写入。

public class MazeNode {
    private int value;//值
    private  int i;//x
    private  int j;//y
    private boolean []wayState;//状态
    public MazeNode(int value,int i,int j) {
         this.value=value;
         this.i=i;
         this.j=j    ;
         wayState=new boolean[Contant.INITSIZE];
    }
    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public void setI(int i) {
        this.i = i;
    }

    public void setJ(int j) {
        this.j = j;
    }
    public int getI() {
        return i;
    }
    public int getJ() {
        return j;
    }
    public boolean getWayState(int direction) {
        return wayState[direction];
    }
    public void setWayState(int direction,boolean isAble) {
        wayState[direction] = isAble;
    }

}

2、然后进行分析，每个迷宫中元素其实是有其特性的。我们利用可以利用接口来实现。

四个方向 ：上、下、左、右；

两个状态：可走、不可走

//接口里的方向
public interface Contant {
    public static final int INITSIZE = 4;

    public static final int WAY_EAST = 0;
    public static final int WAY_SOUTH = 1;
    public static final int WAY_WEST = 2;
    public static final int WAY_NORTH = 3;

    public static final boolean WAY_ABLE = true;
    public static final boolean WAY_DISABLE = false;
}

3、然后添加Maze类进行迷宫的定义和走迷宫的操作，其中主要包括对迷宫该元素的向周边元素路径的处理。

如下代码：

import java.util.Scanner;
import java.util.Stack;
public class Maze {
    private MazeNode[][] mazeNodes;
    private int row;
    private int colum;
    private Stack<MazeNode> stack ;

    public Maze(int row,int colum){
        this.row = row;
        this.colum = colum;
        mazeNodes = new MazeNode[row][colum];
        stack = new Stack<>();
    }
    /**
     * 从键盘上获取值，用来初始化每一个节点
     */
    public void initEveryMazeNode(){
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入迷宫路径");
        for (int i=0;i<row;i++){
            for(int j=0;j<colum;j++){
                int a=scanner.nextInt();
                mazeNodes[i][j] = new MazeNode(a,i,j);
            }
        }
    }
    /**
     * 调整路径状态
     */
    public void adjustWayState(){
        for(int i=0;i<row;i++){
            for(int j=0;j<colum;j++){
                //东
                if(j<colum-1 && mazeNodes[i][j+1].getValue() == 0){
                    mazeNodes[i][j].setWayState(Contant.WAY_EAST,Contant.WAY_ABLE);
                }
                //西
                if(j>0 && mazeNodes[i][j-1].getValue() == 0){
                    mazeNodes[i][j].setWayState(Contant.WAY_WEST,Contant.WAY_ABLE);
                }
                //南
               if(i<row-1&&mazeNodes[i+1][j].getValue()==0){
                    mazeNodes[i][j].setWayState(Contant.WAY_SOUTH,Contant.WAY_ABLE);
               }
                //北
                if(i>0&&mazeNodes[i-1][j].getValue()==0){
                    mazeNodes[i][j].setWayState(Contant.WAY_NORTH,Contant.WAY_ABLE);
                }
            }
        }
    }

    /**
     * 走迷宫：
     */
    public void goMaze(){
        if(mazeNodes[0][0].getValue() != 0){
            System.out.println("没有迷宫路径");
            return;
        }
        stack.push(mazeNodes[0][0]);
        while(!stack.isEmpty()){
            MazeNode top = stack.peek();//获取栈顶元素
            int i=top.getI();  //行角标
            int j=top.getJ();   //列角标
            if(i == row-1 && j == colum-1){
                System.out.println("找到路径");
                break;
            }
            //东
            if(top.getWayState(Contant.WAY_EAST) == Contant.WAY_ABLE){
                stack.push(mazeNodes[i][j+1]);//入东边节点
                //设置东边节点的西边方向为不可走状态
                mazeNodes[i][j].setWayState(Contant.WAY_EAST,Contant.WAY_DISABLE);
                mazeNodes[i][j+1].setWayState(Contant.WAY_WEST,Contant.WAY_DISABLE);
                continue;
            }
            //南
          if(top.getWayState(Contant.WAY_SOUTH)==Contant.WAY_ABLE){
                stack.push(mazeNodes[i+1][j]);
                mazeNodes[i][j].setWayState(Contant.WAY_SOUTH,Contant.WAY_DISABLE);
                mazeNodes[i+1][j].setWayState(Contant.WAY_NORTH,Contant.WAY_DISABLE);
                continue;
          }
            //西
            if(top.getWayState(Contant.WAY_WEST) == Contant.WAY_ABLE){
                stack.push(mazeNodes[i][j-1]);//入西边节点
                //设置西边节点的东边方向为不可走状态
                mazeNodes[i][j].setWayState(Contant.WAY_WEST,Contant.WAY_DISABLE);
                mazeNodes[i][j-1].setWayState(Contant.WAY_EAST,Contant.WAY_DISABLE);
                continue;
            }
            //北
            if(top.getWayState(Contant.WAY_NORTH)==Contant.WAY_ABLE){
                stack.push(mazeNodes[i-1][j]);
                //设置北边节点的南边方向为不可走状态
                mazeNodes[i][j].setWayState(Contant.WAY_NORTH,Contant.WAY_DISABLE);
                mazeNodes[i-1][j].setWayState(Contant.WAY_SOUTH,Contant.WAY_DISABLE);
                continue;
            }
           if(top.getWayState(Contant.WAY_EAST) == false&&top.getWayState(Contant.WAY_WEST) == false&&top.getWayState(Contant.WAY_SOUTH) == false&&top.getWayState(Contant.WAY_NORTH) == false){
                MazeNode mazeNode = stack.pop();
           }
        }
    }

    public void show(){
        if(stack.isEmpty()){
            System.out.println("没有迷宫路径");
            return;
        }
        while(!stack.isEmpty()){
            //查看栈顶元素
            MazeNode top =  stack.peek();
            //改值
                top.setValue(6);
                //获取栈顶值，然后删除
                stack.pop();
        }
        for(int i=0;i<row;i++){
            for(int j=0;j<colum;j++) {
                System.out.print(mazeNodes[i][j].getValue()+"  ");
            }
            System.out.println();
        }
    }


}

4、测试类

public class Testdeom {
    public static  void main(String []args){
        Maze  m=new Maze(4,4);
        m.initEveryMazeNode();
        System.out.println("输入成功，开始走迷宫");
        m.adjustWayState();
        m.goMaze();
        m.show();
    }

}

5、还能处理的问题

puzzle问题：

初始正方形中的带圆圈的数字是可以移动到沿着行的其他正方形的标记。 在拼图的每个步骤，可以移动标记的正方形中由当前占据的整数指示的方格数。 标记可以沿着该行向左或向右移动，但可以不移动经过任一端。 例如，唯一合法的第一步是将标记向右移动三个方格，因为没有空间向左移动三个空格。
拼图的目标是将标记移动到行的远端的0。
要求： 用递归 或 栈或者队列实现编程。如果圆圈能够移动到最后0的位置，返回true，否则返回false。程序要适应任何大小的方格数，并且方格里的数字是随机的，范围是[1,9]。如何检测不能解决的结构，是否存在可以改善执行时间的方法。程序运行，需要输入随机的方格数，然后打印出方格，再打印详细的移动路径。