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