java-maze

用非递归的栈来解决
* 用类来解决迷宫路径的查找问题，寻找一条从左上角迷宫入口
* 到右下角迷宫出口的一条有效路径，0代表可以行走，1代表不能行走，
* 找到，请输入最终的迷宫和路径信息,找不到，请输出不存在有效径。
*
* 软件的运行如下：
*
* 请输入迷宫的行列数(m * n)：5 5
* 请输入迷宫的路径：
0 1 1 1 0
0 0 1 1 1
1 0 0 0 1
0 1 1 0 1
1 1 1 0 0
*
* 正在寻找迷宫路径。。。
*
* 从左上角入口到右下角出口不存在有效路径、、、、
* 路径已找到，输入如下(2代表行走的路径)：
2 1 1 1 0
2 2 1 1 1
1 2 2 2 1
0 1 1 2 1
1 1 1 2 2

项目分析：第一部分：获取用户输入的矩阵的大小，和路径，将矩阵抽象成路径，路径是有方向的，对矩阵中的每一个点开辟一个数组来记录东南西北方向是否可走
{

class Maze{
    private int row;
    private int colum;
    private MazeNode[][] mazePath;
    private SqStack stack;
    //构造函数
    public Maze(int row, int colum){
        this.row = row;
        this.colum = colum;
        mazePath = new MazeNode[this.row][this.colum];
        stack = new SqStack();
    }

    public void setPath(int i, int j, int value){
        mazePath[i][j] = new MazeNode(value, i, j);
    }

    //该函数主要用来根据用户输入的路径更改迷宫节点四个方向的行走状态
    public void adjustMazePath(){
     for(int i=0;i<row;++i)
        for(int j=0;j<colum;++j)
        {
            if(mazePath[i][j].getValue()==0)
            {
                //北
                if(i>0 && mazePath[i-1][j].getValue()==0)
                {
                mazePath[i][j].setPathState(Constant.WAY_NORTH ,Constant.WAY_ENABLE );
                }
               //南
               if(i<row-1&&mazePath[i+1][j].getValue()==0)
               {
                mazePath[i][j].setPathState(Constant.WAY_SOUTH,Constant.WAY_ENABLE );
               } 
               //西
              if(j>0 && mazePath[i][j-1].getValue()==0)
              {
                mazePath[i][j].setPathState(Constant.WAY_WEST,Constant.WAY_ENABLE );
              }
              //东
             if(j<colum-1&&mazePath[i][j+1].getValue()==0)
             {
                            mazePath[i][j].setPathState(Constant.WAY_EAST,Constant.WAY_ENABLE );
             }

        }
    }
}

    //开始寻找迷宫路径*重点及难点*
    public void findMazePath(){
        if(mazePath[0][0].getValue()==0)
        {
            stack.push(mazePath[0][0]);
        }
        //判断每一个节点四个方向的路况，如果可以走就入栈，并更新节点的路况状态，不能退回到原来的节点，如果节点无路就出栈
        while(!stack.empty())
        {
            MazeNode top=stack.top();
            //当走到mazenode[4][4]说明走到出口break;         
            if(top.i==row-1 && top.j==colum-1)break;
            //东向可行就前进一步将东面的节点入栈，更新路况信息
            //将当前节点的东面和东面节点的西面相应的更改为不能过
            if(top.pathState[Constant.WAY_EAST]==1)
            {
                mazePath[top.i][top.j].setPathState(Constant.WAY_EAST, Constant.WAY_DISABLE );
                mazePath[top.i][top.j+1].setPathState(Constant.WAY_WEST,Constant.WAY_DISABLE);
                stack.push(mazePath[top.i][top.j+1]);
                continue;
            }
            //南
            if(top.pathState[Constant.WAY_SOUTH]==1)
            {
                mazePath[top.i][top.j].setPathState(Constant.WAY_SOUTH, Constant.WAY_DISABLE );
                mazePath[top.i+1][top.j].setPathState(Constant.WAY_NORTH,Constant.WAY_DISABLE);
                stack.push(mazePath[top.i+1][top.j]);
                continue;
            }
            //西
            if(top.pathState[Constant.WAY_WEST]==1)
            {
                mazePath[top.i][top.j].setPathState(Constant.WAY_WEST, Constant.WAY_DISABLE );
                mazePath[top.i][top.j-1].setPathState(Constant.WAY_EAST,Constant.WAY_DISABLE);
                stack.push(mazePath[top.i][top.j-1]);
                continue;
            }
            //北
            if(top.pathState[Constant.WAY_NORTH]==1)
            {
                mazePath[top.i][top.j].setPathState(Constant.WAY_NORTH, Constant.WAY_DISABLE );
                mazePath[top.i-1][top.j].setPathState(Constant.WAY_SOUTH,Constant.WAY_DISABLE);
                stack.push(mazePath[top.i-1][top.j]);
                continue;
            }
        }   
}

    //打印最终的迷宫路径信息，栈空说明迷宫没有路可以出去，不为空将栈中的节点元素更改之后输出显示路径
    public void showMazePath()
    {
        MazeNode top;
        if(stack.empty())
        {
            System.out.println("迷宫无路径");

        }
        else
        {
            while(!stack.empty())
            {
                top=stack.top();
                top.value =2;
                stack.pop();    
            }
            System.out.println("迷宫路径为："); 
            for(MazeNode [] arr:mazePath)
            {
                for(MazeNode val:arr)
                {

                    System.out.print(val.value+" "); 
                }
                System.out.println(); 
            }
        }

   }
}

第二部分：
public class MazeNode {
int value;
int i;
int j;
int[] pathState;
public MazeNode(int value, int i, int j){
this.value = value;
this.i = i;
this.j = j;
//初始化节点的四个方向的路径信息，都初始化成不能行走
pathState = new int[Constant.WAY_NUMBER];
for(int k=0; k

猜你喜欢