bfs走迷宫

import java.util.*;  
//广度优先遍历
 class Node{
	int x;
	int y;
	int sp;
}
public class Main {  
    static Scanner in = new Scanner(System.in);  
    static int[][] bool= new int[50][50]; 
    static int[][] maze= new int[50][50]; 
    static int min=Integer.MAX_VALUE;  
    static int p,q,n,m;  
    //方向  
    static int[][] dir= {  
            {0,1},//右  
            {1,0},//下  
            {0,-1},//左  
            {-1,0}//上  
        };  
    static void bfs( Queue<Node> quen){
    	    int  tx=0,ty=0; 
    	   //用来判断是否到达终点
    	    boolean f = false;
    	while(!quen.isEmpty()){
    		//尝试每一种方向
            for (int i = 0; i < 4; i++) {  
                tx=quen.peek().x+dir[i][0];  
                ty=quen.peek().y+dir[i][1];  
                 // 判断坐标是否出界  
                if(tx>n||ty>m||tx<1||ty<1)  
                     continue;  
                //如果没在已经走过的路径上并且是不是障碍物 
                if(bool[tx][ty]==0&&maze[tx][ty]==0){  
                    bool[tx][ty]=1; 
                    Node e =new Node();
                    e.x=tx;
                    e.y=ty;
                    //步数加一
                    e.sp=quen.peek().sp+1;
                    //把当前节点各个方向能走通的节点入队
                    quen.add(e);
                 } 
                if(tx==p&&ty==q){
                	f=true;
                	break;
                }
              } 
            if(f)
               break;
  //从当前节点开始一步能达的节点已经找到，把它出队，以便下一次从它的下一层开始查找
           quen.poll();
    	}
    }  
    public static void main(String[] args) { 
     //设置一个队列来保存每个节点
      Queue<Node> quen=new LinkedList<Node>();
          n=in.nextInt();  
          m=in.nextInt();           
          //创建迷宫  
        for (int i = 1; i <= n; i++) {  
          for (int j = 1; j <= m; j++) {  
              maze[i][j]=in.nextInt();  
              bool[i][j]=0;  
           }  
        }  
        //输入起点终点  
        int start=in.nextInt();  
        int end =in.nextInt(); 
        Node node=new Node();
         node.x=start;
         node.y=end;
         node.sp=0;
         quen.add(node);
         bool[start][end]=1;
         p=in.nextInt();  
         q=in.nextInt();         
           bfs(quen); 
      //队列里面队尾元素的步数即为答案，所以先把其他元素出队，没有直接检索队尾一个元素的方法
        while(quen.size()!=1){
        	quen.poll();
        } 
       System.out.println(quen.peek().sp);
   }  
}

补充一点：Java里面栈用Stack，队列用Linklist，普通数组可以用ArrayList或者对象数组存储，