Java寻找迷宫路径

问题：
/*

• 用非递归的栈来解决
• 用类来解决迷宫路径的查找问题，寻找一条从左上角迷宫入口
• 到右下角迷宫出口的一条有效路径，0代表可以行走，1代表不能行走，
• 找到，请输入最终的迷宫和路径信息， 找不到，请输出“不存在有效路径"。
• */

主函数：

 	package main;
	import java.util.Scanner;
	import maze.Maze;

	public class MainTest {

		public static void main(String[] args) {
				// TODO Auto-generated method stub
				Scanner in = new Scanner(System.in);
				System.out.println("请输入迷宫大小:");
				int size = in.nextInt();
				Maze maze = new Maze(size);   
				System.out.println("请输入迷宫具体的路径信息：0表示路径可以走，1表示路径不能走:");
				for(int i=0; i<size; ++i){
						for(int j=0; j<size; ++j){
								int data = in.nextInt();
								maze.setMazeNode(i, j, data);
						}
				}
				//开始寻找路径信息
				maze.findPath();
				//打印最终的路径信息
				maze.showPath();
		}
}

常量类：

  package constant;
    /**
     * 描述: 定义项目所有的常量
     */
    public interface Constant {
    	
    	//路径的方向总数
    	int PATH_NUM = 4;
    	
    	//右方向
    	int PATH_RIGHT = 0;
    	
    	//下方向
    	int PATH_DOWN = 1;
    	
    	//左方向
    	int PATH_LEFT = 2;
    	
    	//上方向
    	int PATH_UP = 3;
    	
    	//路径可以行走
    	int STATE_OK = 5;
    	
    	//路径不能行走
    	int STATE_ERR = 6;
    }

用来存放路径的类：

 package maze;
    
    import constant.Constant;
    import node.MazeNode;
    import stack.MazeStack;
    
    public class Maze {
    	//存储迷宫路径信息
    	private MazeNode[][] mazePath;
    	
    	//求解迷宫路径所需要的栈类型
    	private MazeStack stack;
    	
    	//表示迷宫路径的大小
    	private int size;
    
    	/**
    	 * 迷宫对象的初始化
    	 * @param size
    	 */
    	public Maze(int size) {
    		// TODO Auto-generated constructor stub
    		this.size = size;
    		stack = new MazeStack();
    		mazePath = new MazeNode[this.size][this.size];
    	}
    	
    	/**
    	 * 给迷宫路径生成相应的节点
    	 * @param i
    	 * @param j
    	 * @param data
    	 */
    	public void setMazeNode(int i, int j, int data) {
    		// TODO Auto-generated method stub
    		mazePath[i][j] = new MazeNode(i, j, data);
    	}
    
    	/**
    	 * 开始寻找迷宫路径信息
    	 */
    	public void findPath() {
    		// TODO Auto-generated method stub
    		if(mazePath[0][0].getVal()!=0) {
    				System.out.println("there is no way!");
    				return;
    		}
    		fixPathState();
    	
    		//开始寻找迷宫路径
    		int i=0;
    		int j=0;
    		stack.push(mazePath[i][j]);
    		
    		while(!stack.empty()) {
    				i=stack.top().getX();
    				j=stack.top().getY();
    				if(i == this.size - 1 && j ==this. size - 1) {
    						break;
    				}
    				//向右
    				if(mazePath[i][j].getPath()[Constant.PATH_RIGHT] == Constant.STATE_OK) {
    						//将该节点 行走 状态设置为不行 
    						mazePath[i][j].setPathState(Constant.PATH_RIGHT, Constant.STATE_ERR);
    						//将该节点 左边行走 状态设置为不行  		
    						mazePath[i][j+1].setPathState(Constant.PATH_LEFT, Constant.STATE_ERR);
    						////将该节点右边节点入栈
    						stack.push(mazePath[i][j+1]);
    						continue;
    				}
    				//向下
    				if(mazePath[i][j].getPath()[Constant.PATH_DOWN] == Constant.STATE_OK) {
    						//将该节点 行走 状态设置为不行 
    						mazePath[i][j].setPathState(Constant.PATH_DOWN, Constant.STATE_ERR);
    						//将该节点 上边行走状态设置为不行 
    						mazePath[i+1][j].setPathState(Constant.PATH_UP, Constant.STATE_ERR);
    						//将该节点下边节点入栈
    						stack.push(mazePath[i+1][j]);
    						continue;
    				}
    				//向左
    				if(mazePath[i][j].getPath()[Constant.PATH_LEFT] == Constant.STATE_OK) {
    						//将该节点 行走 状态设置为不行 
    						mazePath[i][j].setPathState(Constant.PATH_LEFT, Constant.STATE_ERR);
    						//将该节点 右边行走 状态设置为不行 
    						mazePath[i][j-1].setPathState(Constant.PATH_RIGHT, Constant.STATE_ERR);
    						//将该节点左边节点入栈
    						stack.push(mazePath[i][j-1]);
    						continue;
    				}
    				//向上
    				if(mazePath[i][j].getPath()[Constant.PATH_UP] == Constant.STATE_OK) {
    						//将该节点 行走 状态设置为不行 	
    						mazePath[i][j].setPathState(Constant.PATH_UP, Constant.STATE_ERR);
    						//将该节点 下边行走 状态设置为不行 
    						mazePath[i-1][j].setPathState(Constant.PATH_DOWN, Constant.STATE_ERR);
    						//将该节点上边节点入栈
    						stack.push(mazePath[i-1][j]);
    						continue;
    				}
    				stack.pop();	
    		}
    		if(stack.empty()) {
    			System.out.println("no way");
    		}
    }
    
    	/**
    	 * 调整迷宫路径所有节点的行走状态
    	 */
    	private void fixPathState() {
    			// TODO Auto-generated method stub
    			for(int i=0; i<size; ++i){
    					for(int j=0; j<size; ++j){
    							// i, j
    							//向右
    							if(j<size-1 && mazePath[i][j+1].getVal() == 0) {
    									mazePath[i][j].setPathState(Constant.PATH_RIGHT, Constant.STATE_OK); 
    							}
    							//向下
    							if(i<size-1 && mazePath[i+1][j].getVal() == 0) {
    									mazePath[i][j].setPathState(Constant.PATH_DOWN, Constant.STATE_OK); 
    							}
    							//向左
    							if(j>0 && mazePath[i][j-1].getVal() == 0) {
    									mazePath[i][j].setPathState(Constant.PATH_LEFT, Constant.STATE_OK); 
    							}
    							//向上
    							if(i>0 && mazePath[i-1][j].getVal() == 0) {
    									mazePath[i][j].setPathState(Constant.PATH_UP, Constant.STATE_OK); 
    							}
    					}
    			}
    	}
    
    	/**
    	 * 打印迷宫路径信息
    	 */
    	public void showPath() {
    			// TODO Auto-generated method stub
    			while(!stack.empty()) {
    					int i=stack.top().getX();
    					int j=stack.top().getY();
    					this.setMazeNode(i, j, 7);
    					stack.pop();
    			}
    			System.out.println("迷宫路径信息(路径可以走 7表示):");
    			for(int i=0 ; i<size;i++) {
    					for(int j=0;j<size;j++) {
    							System.out.print(this.mazePath[i][j].getVal()+" ");
    					}
    					System.out.println();
    			}
    	}
    }

迷宫路径节点的类型信息类：

    package node;
    import constant.Constant;
    public class MazeNode {
    	//存储节点的值
    	private int val;
    	
    	//存储节点的坐标
    	private int x;
    	private int y;
    	
    	//存储节点四个方向的行走状态
    	private int[] path;
    
    	/**
    	 * 节点对象的初始化
    	 * @param i
    	 * @param j
    	 * @param data
    	 */
    	public MazeNode(int i, int j, int data) {
    		// TODO Auto-generated constructor stub
    		this.x = i;
    		this.y = j;
    		this.val = data;
    		
    		//初始化节点的四个方向行走信息的时候，都初始化成不能走
    		path = new int[Constant.PATH_NUM];
    		for(int k=0; k<path.length; ++k){
    				path[k] = Constant.STATE_ERR;
    		}
    	}
    
    	public int getVal() {
    			return val;
    	}
    
    	public void setVal(int val) {
    			this.val = val;
    	}
    
    	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 int[] getPath() {
    			return path;
    	}
    
    	public void setPath(int[] path) {
    			this.path = path;
    	}
    
    	/**
    	 * 把节点相应的方向path，的行走状态，修改为state
    	 * @param pathRight
    	 * @param stateOk
    	 */
    	public void setPathState(int pathid, int state) {
    			// TODO Auto-generated method stub
    			this.path[pathid] = state;
    	}
    }

迷宫需要的顺序栈结构 (内存可增长):

    package stack;
    import java.util.Arrays;
    import node.MazeNode;
    public class MazeStack {
        private MazeNode[] stack;
        private int top;
    	
    	public MazeStack(){
    		this.stack = new MazeNode[10];
    		this.top = 0;
    	}
    	/**
    	 * 入栈
    	 * @param val
    	 */
    	public void push(MazeNode mazeNode) {
    			if(full()) {
    					this.stack=Arrays.copyOf(this.stack, 2*this.top);
    			}
    			this.stack[this.top]=mazeNode;
    			this.top++;
    	}
    	/**
    	 * 出栈
    	 */
    	public void pop() {
    			if(empty()) {
    					return;
    			}
    			this.top--;
    	}
    	
    	/**
    	 *  返回栈顶元素
    	 * @return
    	 */
    	public MazeNode top() {
    			return this.stack[this.top-1];
    	}
    	
    	/**
    	 * 判断栈空
    	 * @return
    	 */
    	public boolean empty() {
    			return this.top == 0;
    	}
    	/**
    	 * 判断栈满
    	 * @return
    	 */
    	public boolean full() {
    			return this.top == this.stack.length;
    	}
    }

运行结果：

请输入迷宫大小:
5
请输入迷宫具体的路径信息：0表示路径可以走，1表示路径不能走:
0 0 0 0 1
1 0 1 0 1
0 0 1 1 1
0 1 0 0 1
0 0 0 0 0
迷宫路径信息(路径可以走 7表示):
7 7 0 0 1
1 7 1 0 1
7 7 1 1 1
7 1 0 0 1
7 7 7 7 7