链式栈实现迷宫寻径

测试类

public class maintest {
  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();
       }
       Migong2 mi=new Migong2(map);
       if(mi.findpath()){//寻找路径，存在路径时返回1
            System.out.println("迷宫有路,走迷宫的一条路径为：");
             //输出迷宫的路径
            Migong2.Point1[] 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 Stack<E>{
  E push(E item); //入栈
  E pop(); //出栈
  E peek(); //取栈顶元素
  int size(); //返回栈中元素的个数
  boolean empty(); //判断栈是否为空
}

链式数据类型

public class StackNode<E> {//定义对数据设置获取等基本操作，简化对对象的操作步骤，链表的结构所以从链头加入
     private E data; // 数据域
     private StackNode<E> next; // 引用域
    //构造函数
    public StackNode(){}
    public StackNode(E data) {
        this.data = data;
    }
    public StackNode(E data, StackNode<E> next) {
        super();
        this.data = data;
        this.next = next;
    }
   //数据域get属性
    public E getData() {
       return data;
    }
    //数据域set属性
    public void setData(E data) {
       this.data = data;
    }
    //引用域get属性
    public StackNode<E> getNext() {
       return next;
    }
    //引用域get属性
    public void setNext(StackNode<E> next) {
       this.next = next;
    }
}

实现链式栈

public class LinkStack<E> implements Stack<E> {
   private StackNode<E> top; // 栈顶指示器
   private int size; // 栈中结点的个数
   // 初始化链栈
   public LinkStack() {
       top = null;
       size = 0;
   }
   // 入栈操作
   public E push(E item) {
       StackNode<E> newnode = new StackNode<E>(item);
       if (!empty()) 
            newnode.setNext(top);
       top = newnode;
       ++size;
       return item;
  }
  // 出栈操作
  public E pop() {
    E item=null;
    if (!empty()){
        item = top.getData();
        top = top.getNext();
        size--;
    }    
    return item;
  }
  // 获取栈顶数据元素
  public E peek() {
    E item=null;
    if (!empty()){
        item=top.getData();
    }
    return item;
  }
  // 求栈的长度
  public int size() {
       return size;
  }
  // 判断顺序栈是否为空
  public boolean empty() {
     if ((top == null) && (size == 0)){
       return true;
     }else{
       return false;
     }
   }
}

主方法类

public class Migong2 {//寻找迷宫的方法类
  int[][] maze;
  int row,col;
  LinkStack< Point1> sta;
  
  Point1[] move={new Point1(0,1),new Point1(1,1),//八个方向
    new Point1(1,0),new Point1(1,-1),new Point1(0,-1),
    new Point1(-1,1),new Point1(-1,0),new Point1(-1,1)};

  public Migong2(int[][] map){//构造方法
      row=map.length+2;
      col=map[0].length+2;
      sta= new LinkStack<Point1>();//创建栈 使用链式栈，也可以使用顺序栈
      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;
    Point1 temp=null;
    temp=new Point1(1,1,-1);
    sta.push(temp);
    while(!sta.empty()){
        temp=sta.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 Point1(x,y,d);
                sta.push(temp);
                x=i;y=j;maze[x][y]=-1;
                if(x==row-2 && y==col-2){
                       temp=new Point1(x,y,-1);
                       sta.push(temp);
                       return true;//迷宫可达
                }
                else d=0;//向下继续便利
             }
             else d++; // 
        }
     }
     return false; 
  }
  public Point1[] getpath(){//将栈的数据存进point数组里面
    Point1[] points = new Point1[sta.size()];
    for(int k=points.length-1;k>=0;k--){
      points[k]=sta.pop();
    }
    return points;
  }
  
  public class Point1{//用于存储结点
    public int x,y,d;
    public Point1(int x,int y){
      this.x=x;
      this.y=y;
   }
   public Point1(int x,int y,int d){
       this.x=x;
       this.y=y;
       this.d=d;
   }
  }
}