数据结构迷宫java_严蔚敏《数据结构》中迷宫算法java实现

总的来说，这个程序运行得不错，可以任意修改迷宫图，但是有一点儿毛病:第一，如果终点不可达，程序陷入循环状态。改良思想，可以写个判断终点或起点是否合法的方法。也可以给所经过的路径标记，如果所以的点都经过了，则退出程序。其次，在switch分支中，以这样的顺序：下、右、上、左 探索的话，则有些点是无法到达的，如点(18，1)，这些点称为盲点，只向一个方向绕过去是永远达到 的。解决思路：让探索既向逆时针探索，又向顺时针探索。以下是代码：(已经测试过，保证正确运行)

package test1;

import java.util.Random;

public class Migong

{

static int maze[][];

Stack stack =new Stack();

Random r=new Random();

int count=0+r.nextInt(20);

//long count=100; //在nextPos方法中，用来来回实行case；

int i=1; //在nextPos方法中，用来来回实行case；

String flag="ni"; //在nextPos方法中，用来来回实行case；

//String flag="ni";

public static void main(String []args)

{

Migong mg=new Migong();

maze=mg.initMaze();

//Stack stackWithPath=mg.findPath( mg.stack,new Position(1,0),new Position(18,19));

//Stack stackWithPath=mg.findPath( mg.stack,new Position(15,18));

//Stack stackWithPath=mg.findPath( mg.stack,1));

//Stack stackWithPath=mg.findPath( mg.stack,new Position(9,9));

//Stack stackWithPath=mg.findPath( mg.stack,new Position(3,1));

Stack stackWithPath=mg.findPath( mg.stack,39));

mg.printFindPath(stackWithPath,maze);

}

public boolean jugePos(Position p)

{

if( maze[p.x][p.y]==1)

{

System.out.println("对不起，请输入合法的起点和终点！");

return false;

}

else

return true;

}

public void printFindPath(Stack st,int maze[][])

{

if(st==null)

{

System.out.println("对不起，栈为null！");

}

else

{

if(!st.isEmpty())

{

while(!st.isEmpty())

{

Node node=st.pop();

maze[node.position.x][node.position.y]=-1;

}

printMaze(maze);

}

else

{

System.out.println("对不起，栈为空值！");

}

}

}

public Stack findPath(Stack stack,Position start,Position end)

{

int curstep=1; //当前步骤数目

Position curpos=start; //当前位置

Node node;

if(!jugePos(start)||!jugePos(end))

{

return null;

}

else

{

do

{

if(isPass(curpos))

{

node=new Node(curstep,curpos,1);

stack.push(node);

footPrint(curpos);//这里有些小毛病，就是探索进入死胡同，而需要回溯的时候，显然我们已经打印了这些不该打印的路径，

while(curpos.equals(end))

{

System.out.println("找到出口了，恭喜！");

return stack;

}

curpos=nextPos(curpos,1);

curstep=curstep+1;

}

else

{

if(!stack.isEmpty())

{

node=(Node)stack.peek();

if(node.di<4) //这个地方书上的算法是while，显然是不对的，应该是if；

{

Node n=(Node)stack.pop();

++n.di; //如果di是3的话，由于3<4,满足进入第一个if分支条件，自增后di是4，

//随后实行push，和nextPos，实行nextPos时就是向左探索。

stack.push(n);

curpos=nextPos(n.position,n.di);

}

else //注意，这里不能是if(node.di==4)，也不能是while(di==4)，因为如果那样，

{ //则当di=3时，既满足实行第一个分支，又满足实行第二个分支(因为实行进入第一个if分支后，

//di变成4，又满足了第二个分支的条件，这样就导致di=4时不能实行向左边探索的任务。

markPrint(node.position);

stack.pop();

}

}

}

}while(!stack.isEmpty());

}

if(stack.getLength()==0)

System.out.println("找不到出口！");

return null;

}

public void markPrint(Position p)

{

System.out.println("点("+p.x+","+p.y+")碰壁！");

}

public Position nextPos(Position curpos,int di)

{

Position pos=new Position(curpos.x,curpos.y);

if(flag=="ni"||flag.equals("ni"))

{

switch(di)

{ case 1:{pos.x+=1;break ;}//向下

case 2:{pos.y+=1;break ;}//向右

case 3:{pos.x-=1;break ;}//向上

case 4:{pos.y-=1;break ;}//向左

}

i++;

if(i>=count) //1 50000 100000 150000

{

//flag="shun";

i=1;

}

System.out.println("逆时针：下，右，上，左");

count=0+r.nextInt(20);

}

else if(flag=="shun"||flag.equals("shun"))

{

switch(di)

{ case 2:{pos.x+=1;break ;}//向下

case 1:{pos.y+=1;break ;}//向右

case 4:{pos.x-=1;break ;}//向上

case 3:{pos.y-=1;break ;}//向左

}

i++;

if(i>=count)

{

//flag="luan";

i=1;

}

System.out.println("顺时针：右，下，左，上");

count=0+r.nextInt(30);

}

else

{

switch(di)

{ case 1:{pos.x+=1;break ;}//向下

case 3:{pos.y+=1;break ;}//向右

case 2:{pos.x-=1;break ;}//向上

case 4:{pos.y-=1;break ;}//向左

}

i++;

if(i>=count)

{

//flag="ni";

i=1;

}

System.out.println("乱时针:下，上，右，左");

count=0+r.nextInt(30);

}

return pos;

}

public void footPrint(Position curpos)

{

System.out.print("点("+curpos.x+","+curpos.y+")可通过！");

System.out.println(" ");

}

public boolean isPass(Position curpos)//不仅测试当前位置是否为0，还需要把当前的Position构造成Node，然后

{ //在stack找，看看是不是已经存在该位置，如果是，则该位置不能通过，否则可以通过;

Stack temSt=stack;

Node thisNode=new Node(curpos);

if(!temSt.isEmpty())

{

return (maze[curpos.x][curpos.y]==0&&!temSt.hasIt(thisNode));

}

else

{

return maze[curpos.x][curpos.y]==0;

}

}

public int[][] initMaze()// 20行,40列,这个数目跟printMaze()相关。

{

int maze[][]={ // 5 10 15 20 25 30 35 40

{1,1,1},

{0,

{1,//5

{1,//10

{1,//15

{1,0},//20

};

printMaze(maze);

return maze;

}

public void printMaze(int maze[][])

{

for(int i=0;i<20;i++)

{

for(int j=0;j<40;j++)

{

if(maze[i][j]==1)

System.out.print("■");

else if(maze[i][j]==0)

System.out.print("□");

else

System.out.print("＊");

}

System.out.println();

}

}

}

class Node

{

int ord;

Position position;

int di;

public Node(Position p)

{

this.position=p;

}

public Node(int ord,Position p,int di)

{

this.ord=ord;

this.position=p;

this.di=di;

}

@Override

public int hashCode() {

final int PRIME = 31;

int result = 1;

result = PRIME * result + ((position == null) ? 0 : position.hashCode());

return result;

}

@Override

public boolean equals(Object obj) {

if (this == obj)

return true;

if (obj == null)

return false;

if (getClass() != obj.getClass())

return false;

final Node other = (Node) obj;

if (position == null) {

if (other.position != null)

return false;

} else if (!position.equals(other.position))

return false;

return true;

}

}

class Position { int x; int y; public Position(){}; public Position(int x,int y) { this.x=x; this.y=y; } @Override public int hashCode() { final int PRIME = 31; int result = 1; result = PRIME * result + x; result = PRIME * result + y; return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; final Position other = (Position) obj; if (x != other.x) return false; if (y != other.y) return false; return true; } }

相关文章

总结

如果觉得编程之家网站内容还不错，欢迎将编程之家网站推荐给程序员好友。

本图文内容来源于网友网络收集整理提供，作为学习参考使用，版权属于原作者。

如您喜欢交流学习经验，点击链接加入交流1群：1065694478(已满)交流2群：163560250