问题：

/*

用非递归的栈来解决

用类来解决迷宫路径的查找问题，寻找一条从左上角迷宫入口

到右下角迷宫出口的一条有效路径，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

for(int j=0; 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

for(int j=0; j

// i, j

//向右

if(j

mazePath[i][j].setPathState(Constant.PATH_RIGHT, Constant.STATE_OK);

}

//向下

if(i

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

for(int j=0;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[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