迷宫算法（java实现）

迷宫问题是栈的典型应用，因此借助栈来实现迷宫问题；
*题目描述：用类来解决迷宫路径的查找问题，寻找一条从左上角迷宫入口到右下角迷宫出口的一条有效路径，0代表可以行走，1代表不能行走，找到，请输入最终的迷宫和路径信息， 找不到，请输出不存在有路径。
例如：
* 请输入迷宫的行列数(m * n)：5 5
* 请输入迷宫的路径：
* 0 0 1 0 0
* 1 0 0 1 0
* 0 1 0 1 0
* 0 0 0 1 0
* 0 0 0 0 0
* 正在寻找迷宫路径。。。
* 结果：
* 从左上角入口到右下角出口不存在有效路径 ；
* 路径已找到，输入如下(2代表行走的路径）
* 2 2 1 0 0
* 1 2 2 1 0
* 0 1 2 1 0
* 0 0 2 1 0
* 0 0 2 2 2
* /
* 实现该算法，共定义了四个类；
（1）首先给出栈的抽象数据类型结构：StackADT：主要包括入栈，出栈，判空，判满，取栈顶数据元素；

class SqStack{    private MazeNode[] stack;    private int top;    public SqStack(){        top = 0;        stack = new MazeNode[50];    }    public void push(MazeNode node){        if(full()){            resize();        }        this.stack[++top]=node;    }    public void pop(){        if(empty())            return;        top--;      }    public MazeNode top(){        return this.stack[top-1];    }    public boolean empty(){        return this.top==0;     }    public boolean full(){        return this.top==this.stack.length;    }    private void resize(){        stack=Arrays.copyOf(stack, stack.length*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);    }}

（3）结点类，包括结点的行列，结点的值，以及结点的状态；

public class MazeNode {    private int value;    private int i;    private int j;    private 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 < pathState.length; ++k) {            pathState[k] = Constant.WAY_DISABLE;        }    }    //设置该结点的行走状态    public void setPathState(int path, int state) {         pathState [path]= state;    }    //获取该结点的状态    public int[] getPathState() {        return pathState;    }    //获取该结点的value值    public int getValue() {        return value;    }    //设置该结点的value值    public void setValue(int value) {        this.value = value;    }    public int getRow() {        return i;    }    public void setRow(int i) {        this.i = i;    }    public int getCol() {        return j;    }    public void setCol(int j) {        this.j = j;    }}

（4）constant(这个类主要是定义次项目中所用到的常量）

public class Constant {    //表示方向总数；    public static int WAY_NUMBER=4;    //表示路径可以走；    public static int WAY_ENABLE=1;    //表示路径不可以走；    public static int WAY_DISABLE=0;     //表示迷宫结点 四个方向；    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;}

实现该算法主要用到三个函数：
（1）maze.adjustMazePath(); //该函数主要用来更改迷宫节点四个方向的行走状态

public void adjustMazePath(){        for(int i=0;i<row;i++){            for(int j=0;j<colum;j++){                if(mazePath[i][j].getValue()==0){                    //东  if(j<colum-1 && mazePath[i][j+1].getValue()==0 ){  //当前结点的东边结点为0，东边路径设为可以走；        mazePath[i][j].setPathState(Constant.WAY_EAST, Constant.WAY_ENABLE);                    }                //南 if(i<row-1&& mazePath[i+1][j].getValue()==0){   //当前结点的南边结点为0，南边路径设为可以走；      mazePath[i][j].setPathState(Constant.WAY_SOUTH, Constant.WAY_ENABLE);                }       //西     if(j>0 && mazePath[i][j-1].getValue()==0){  //当前结点的西边结点为0，西边路径设为可以走；                    mazePath[i][j].setPathState(Constant.WAY_WEST, Constant.WAY_ENABLE);                }      //北     if(i>0 && mazePath[i-1][j].getValue()==0){  //当前结点的北边结点为0，北边路径设为可以走；    mazePath[i][j].setPathState(Constant. WAY_NORTH, Constant.WAY_ENABLE);                      }            }        }    }}

（2）maze.findMazePath(); //开始寻找迷宫路径

public void findMazePath(){        int i=0,j=0;        stack.push(mazePath[i][j]);        while(!stack.empty()){            MazeNode top=stack.top();if (top.getRow()==row-1 && top.getCol()==colum-1)   break;        //东边可以走        if(mazePath[top.getRow()][top.getCol()].getPathState()[Constant.WAY_EAST]== Constant.WAY_ENABLE){        mazePath[top.getRow()][top.getCol()].setPathState(Constant.WAY_EAST, Constant.WAY_DISABLE); //当前结点的东设为不能走(不能再走回去)        mazePath[top.getRow()][top.getCol()+1].setPathState(Constant.WAY_WEST, Constant.WAY_DISABLE); //东边结点的西设为不能走；           stack.push(mazePath[top.getRow()][top.getCol()+1]);   //东边结点压入栈                continue;               }            //南边可以走            else  if(mazePath[top.getRow()][top.getCol()].getPathState()[Constant.WAY_SOUTH]== Constant.WAY_ENABLE){                mazePath[top.getRow()][top.getCol()].setPathState(Constant.WAY_SOUTH, Constant.WAY_DISABLE); //当前节点的南设为不能走；                mazePath[top.getRow()+1][top.getCol()].setPathState(Constant.WAY_NORTH,  Constant.WAY_DISABLE);//南边结点的北设为不能走；                stack.push(mazePath[top.getRow()+1][top.getCol()]);   //南边结点压入栈                continue;            }            //西边可以走            else  if(mazePath[top.getRow()][top.getCol()].getPathState()[Constant.WAY_WEST]== Constant.WAY_ENABLE){                mazePath[top.getRow()][top.getCol()].setPathState(Constant.WAY_WEST, Constant.WAY_DISABLE);   //当前结点的西设为不能走                mazePath[top.getRow()][top.getCol()-1].setPathState(Constant.WAY_EAST, Constant.WAY_DISABLE);  //西边结点的东设为不能走                stack.push(mazePath[top.getRow()][top.getCol()-1]);  //西边结点压入栈                continue;            }            //北边可以走            else if(mazePath[top.getRow()][top.getCol()].getPathState()[Constant. WAY_NORTH]== Constant.WAY_ENABLE){                mazePath[top.getRow()][top.getCol()].setPathState(Constant. WAY_NORTH, Constant.WAY_DISABLE); //当前节点的北设为不能走；                mazePath[top.getRow()-1][top.getCol()].setPathState(Constant.WAY_SOUTH,Constant.WAY_DISABLE); //北边节点的南设为不能走；                stack.push(mazePath[top.getRow()-1][top.getCol()]);   //北边结点压入栈                continue;            }         stack.pop();           }    }

(3)maze.showMazePath() ;//打印迷宫路径；

public void showMazePath(){        while(!stack.empty()){  //栈非空，栈中元素即为找到的路径，将找到的路径改为2；            MazeNode p=stack.top();            mazePath[p.getRow()][p.getCol()].setValue(2);            stack.pop();        }        System.out.println("迷宫路径已找到（2代表行走的路径）");        for(int i=0;i<colum;i++){            for(int j=0;j<row;j++){                System.out.print(mazePath[i][j].getValue());                System.out.print(" ");            }            System.out.println("\n");        }    }  }

main函数

“`
public class TestMazePathDemo {

public static void main(String[] args) {    // TODO Auto-generated method stub    Scanner scan = new Scanner(System.in);    System.out.print("请输入迷宫的行列数(m * n):");    int row = scan.nextInt();    int col = scan.nextInt();    //maze现在代表的就是整个迷宫对象    Maze maze = new Maze(row, col);    System.out.println("请输入迷宫的路径：");    for(int i=0; i<row; ++i){        for(int j=0; j<col; ++j){            int data = scan.nextInt();            maze.setPath(i, j, data);        }    }    //以上代码，就把整个迷宫路径的信息都设置到maze对象里面了    maze.adjustMazePath;    System.out.println("正在寻找迷宫路径");    maze.findMazePath();    maze.showMazePath();}

}
运行结果如下：