顺序栈实现迷宫寻径

测试类

public class MazeTest{
public static void main(String[] args) {
int[][] map={
{1,1,1,1,1,1,1,1,1,1},
{1,0,1,0,1,0,1,1,1,1},
{1,0,0,1,0,1,0,1,1,1},
{1,1,1,1,0,1,0,0,1,1},
{1,0,1,0,1,1,1,0,1,1},
{1,1,0,1,1,1,0,0,0,1},
{1,0,1,1,0,0,1,1,0,1},
{1,1,1,1,1,1,1,1,1,1}
};
int row=map.length,col=map[0].length;
System.out.println("迷宫矩阵：");
for(int i=1;i<row-1;i++){
for(int j=1;j<col-1;j++){
 System.out.print(map[i][j]+" ");
}
System.out.println();
}
Migong mi=new Migong(map);
if(mi.findpath()){//寻找路径，存在路径时返回1
            System.out.println("迷宫有路,走迷宫的一条路径为：");
             //输出迷宫的路径
            test2.Migong.Point[] points=mi.getpath();
            for(int o=0;o<points.length;o++){
            System.out.print("("+points[o].x+","+points[o].y+")");
            }
        }else System.out.println("迷宫无路！");
    }
}

实现顺序栈

栈接口

public interface IStack<E> {
 E push(E item); //入栈
 E pop(); //出栈
 E peek(); //取栈顶元素
 int size(); //返回栈中元素的个数
 boolean empty(); //判断栈是否为空
}

数组实现

public class SeqStack<E> implements IStack<E>{//顺序表
private int maxsize; // 顺序栈的容量
private E[] data; // 数组，用于存储顺序栈中的数据元素
private int top; // 指示顺序栈的栈顶


// 初始化栈
public SeqStack(Class<E> type, int size) {
E[] newInstance = (E[]) Array.newInstance(type, size);
data = newInstance;
maxsize = size;
top = -1;
}
// 入栈操作
public E push(E item) {
if (!isFull()) {
data[++top] = item;
return item;
}
       else
return null;
}
// 出栈操作
public E pop() {
E item = null;
if (!empty()) {
item = data[top--];
}
return item;
}

// 获取栈顶数据元素
public E peek() {
E item = null;
if (!empty()) {
item = data[top];
}
return item;
}
//求栈的长度
    public int size() {
return top+1;
}
// 判断顺序栈是否为空
public boolean empty() {
if (top == -1) {
return true;
} else {
return false;
}
}
// 判断顺序栈是否为满
public boolean isFull() {
if (top == maxsize - 1) {
return true;
} else {
return false;
}
}

}

主方法类

public class Migong {
  int[][] maze;
  int row,col;
  SeqStack< Point> stack;
  
  Point[] move={new Point(0,1),new Point(1,1),//八个方向
    new Point(1,0),new Point(1,-1),new Point(0,-1),
    new Point(-1,1),new Point(-1,0),new Point(-1,1)};

  public Migong(int[][] map){//构造方法
row=map.length+2;
col=map[0].length+2;
stack= new SeqStack<Point>(Point.class,row*col);//创建栈 使用链式栈，也可以使用顺序栈
maze=new int[row][col];
for(int X=1;X<row-1;X++){
for(int Y=1;Y<col-1;Y++){
maze[X][Y]=map[X-1][Y-1];
}
}
  }
 
public boolean findpath(){//探寻路径
row=maze.length;
col=maze[0].length;
int x,y,d,i,j;
Point temp=null;
temp=new Point(1,1,-1);
stack.push(temp);
while(!stack.empty()){
temp=stack.pop();
x=temp.x;y=temp.y;d=temp.d+1;
while(d<8){//广度优先搜索
i=x+move[d].x; j=y+move[d].y;
if(maze[i][j]==1){
temp=new Point(x,y,d);
stack.push(temp);
x=i;y=j;maze[x][y]=-1;
if(x==row-2 && y==col-2){
temp=new Point(x,y,-1);
                       stack.push(temp);
return true;//迷宫可达
}
else d=0;//向下继续便利
}
else d++; //
}
}
return false;
  }

  public Point[] getpath(){
  Point[] points = new Point[stack.size()];
    for(int k=points.length-1;k>=0;k--){
    points[k]=stack.pop();
  }
  return points;
  }
  
  public class Point{
  public int x,y,d;
  public Point(int x,int y){
  this.x=x;
  this.y=y;
  }
  public Point(int x,int y,int d){
  this.x=x;
  this.y=y;
  this.d=d;
  }
  }
}