import java.util.LinkedList;
//import java.util.Stack;
public class Maze {
public static void mazePath(int maze[][],int direction[][],int x1,int y1,int x2,int y2){
int  i,j,k;
int g,h;
LinkedList<Node> list=new LinkedList<Node>();
Node element=new Node();
maze[x1][y1]=2;      //从人口点开始做标记
element.setX(x1);
element.setY(y1);
element.setD(-1);
list.push(element);     //人口点进栈
while(!list.isEmpty()){     /*走不通时,一步步回退*/
element=(Node)list.pop();
//list.pop();
i=element.getX();
j=element.getY();
k=element.getD()+1; while(k<=3){             //依次试探每个方向
g=i+direction[k][0];
h=j+direction[k][1]; if(g==x2&&h==y2&&maze[g][h]==0){   //走到出口点时
System.out.println("THE revers path is");
while(!list.isEmpty()){         //打印路径上的每一点
element=(Node)list.pop();
//list.pop();
System.out.println("("+element.getX()+","+element.getY()+")");
}
return;
}
if(maze[g][h]==0){               //走到没走过的点
maze[g][h]=2; //做标记
element.setX(i);
element.setY(j);
element.setD(k); list.push(element);   
i=g;
j=h;
k=-1;

}
k=k+1;
}
}
System.out.println("Not found!");
}


public static void main(String[] args) {
//定义一个迷宫矩阵,0表示可以通过,1表示不可以通过
int maze[][]={{1,1,1,1,1,1},
      {1,0,0,1,0,1},
      {1,0,0,0,0,1},
      {1,1,1,1,0,1}};
//定义了某个点上下左右四个方向
int direction[][]={{0,1},{1,0},{0,-1},{-1,0}};
                //从(1,1)到(3,4)点的路径。
mazePath(maze,direction,1,1,3,4);


}
}
class Node{
private int x;
private int y;
private int d;
public Node(){

}
public Node(int x,int y){
this.x=x;
this.y=y;
}

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 getD() {
return d;
}
public void setD(int d) {
this.d = d;
}

}为什么结果
THE revers path is
(2,4)
(2,4)
(2,4)
(2,4)
好像逻辑没有错误,请大家帮忙看看

解决方案 »

  1.   

    逻辑错误很难直接看出来,
    在eclipse下单步调试吧
      

  2.   

    答:其实还是代码上的逻辑错误。正确运行的代码如下:
    import java.util.LinkedList;
    //import java.util.Stack;
    public class Maze {
        public static void mazePath(int maze[][],int direction[][],int x1,int y1,int x2,int y2){
            int  i,j,k;
            int g,h;
            LinkedList<Node> list=new LinkedList<Node>();
            Node element=new Node();
            maze[x1][y1]=2;      //从人口点开始做标记
            element.setX(x1);
            element.setY(y1);
            element.setD(-1);
            list.push(element);        //人口点进栈
            while(!list.isEmpty()){     /*走不通时,一步步回退*/
                element=(Node)list.pop();
                //list.pop();
                i=element.getX();
                j=element.getY();
                k=element.getD()+1;            while(k<=3){             //依次试探每个方向
                    g=i+direction[k][0];
                    h=j+direction[k][1];                if(g==x2&&h==y2&&maze[g][h]==0){   //走到出口点时
                     list.push(element);//<======
                     element=new Node();//<======
                        maze[g][h]=2;                    //做标记
                        i=g;
                        j=h;
                        k=-1;
                        element.setX(i);
                        element.setY(j);
                        element.setD(k);                    list.push(element);
                        
                        System.out.println("THE revers path is");
                        while(!list.isEmpty()){         //打印路径上的每一点
                            element=(Node)list.pop();
                            //list.pop();
                            System.out.println("("+element.getX()+","+element.getY()+")");
                        }
                        return;
                    }
                    if(maze[g][h]==0){               //走到没走过的点
                     list.push(element);//<======
                     element=new Node();//<======
                        maze[g][h]=2;                    //做标记
                        i=g;
                        j=h;
                        k=-1;
                        element.setX(i);
                        element.setY(j);
                        element.setD(k);                    list.push(element);  
                        break;
                        
                    }
                    k=k+1;
                }//while
            }
            System.out.println("Not found!");
        }
        
        
        public static void main(String[] args) {
            //定义一个迷宫矩阵,0表示可以通过,1表示不可以通过
            int maze[][]={{1,1,1,1,1,1},
                      {1,0,0,1,0,1},
                      {1,0,0,0,0,1},
                      {1,1,1,1,0,1}};
            //定义了某个点上下左右四个方向
            int direction[][]={{0,1},{1,0},{0,-1},{-1,0}};
                    //从(1,1)到(3,4)点的路径。
            mazePath(maze,direction,1,1,3,4);
            
            
        }
    }
    class Node{
        private int x;
        private int y;
        private int d;
        public Node(){
            
        }
        public Node(int x,int y){
            this.x=x;
            this.y=y;
        }
        
        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 getD() {
            return d;
        }
        public void setD(int d) {
            this.d = d;
        }
        
    }
    程序运行结果:
    THE revers path is
    (3,4)
    (2,4)
    (2,3)
    (2,2)
    (1,2)
    (1,1)