顺序队列实现迷宫寻经

测试类

public class Testqueue {
  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();
    }
    Migong3 mi=new Migong3(map);
    if(mi.findpath()){//寻找路径，存在路径时返回1
           System.out.println("迷宫有路,走迷宫的一条路径为：");
             //输出迷宫的路径
            Migong3.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 IQueue<E> {//定义队列接口
    boolean enqueue(E item); //入队列操作
    E dequeue(); //出队列操作
    E peek(); //取对头元素
    int size(); //求队列的长度
    boolean isEmpty(); //判断队列是否为空  
    boolean isFull(); //判断队列是否为满  
}

组数实现

public class SeqQueue<E> implements IQueue<E> {//利用顺序结构实现队列接口
   private int maxsize; //队列的容量
   private E[] data; // 存储循环顺序队列中的数据元素
   private int front; // 指示最近一个己经离开队列的元素所占的位置
   private int rear; // 指示最近一个进行入队列的元素的位置
    //初始化队列
   public SeqQueue(Class<E> type, int maxsize) {
        data = (E[]) Array.newInstance(type, maxsize);
        this.maxsize = maxsize;
        front = rear = -1;
   }
   //入队列操作
   public boolean enqueue(E item) {
       if (!isFull()) {
           rear = (rear + 1) % maxsize;
           data[rear] = item;
          return true;
       } else
       return false;
   }
   //出队列操作
   public E dequeue() {
      if (!isEmpty()) {
         front = (front + 1) % maxsize;
         return data[front];
       } else
         return null;
    }
   //取对头元素
   public E peek() {
      if (!isEmpty()) {
         return data[(front + 1) % maxsize];
      }else
          return null;
   }
   //求队列的长度
   public int size() {
        return (rear - front + maxsize) % maxsize;
   }
   // 判断队列是否为空
   public boolean isEmpty() {
      if (front == rear) {
         return true;
      }else{
         return false;
      }
  }
  // 判断循环顺序队列是否为满
  public boolean isFull() {
     if ((front == -1 && rear == maxsize - 1)|| (rear + 1) % maxsize == front) {
            return true;
     } else {
         return false;
     }
  }
}

主方法类

public class Migong3 {//利用顺序队列的存储结构寻找迷宫
  int[][] maze;
  int row,col;
  SeqQueue< Point> queue; 
  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 Migong3(int[][] map){//构造方法
 row=map.length+2;
 col=map[0].length+2;
 queue= new SeqQueue<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);
  queue.enqueue(temp);
  while(!queue.isEmpty()){
       temp=queue.dequeue();
       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);
                queue.enqueue(temp);
                x=i;y=j;maze[x][y]=-1;
                if(x==row-2 && y==col-2){
                       temp=new Point(x,y,-1);
                       queue.enqueue(temp);
                       return true;//迷宫可达
                }
                else d=0;//向下继续便利
           }
           else d++; // 
       }
    }
    return false; 
  }
  public Point[] getpath(){
    Point[] points = new Point[queue.size()];
    for(int k=points.length-1;k>=0;k--){
       points[k]=queue.dequeue();
    }
    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;
   }
  }
}