问题：
/*
- 用非递归的栈来解决
- 用类来解决迷宫路径的查找问题，寻找一条从左上角迷宫入口
- 到右下角迷宫出口的一条有效路径，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
173
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
