随机生成一个迷宫并探索一条路径的JAVA实现

问题：实现一个随机迷宫，可以想象是一个二维数组，入口在左上角，出口在右下角。
要求：

1、不能超过边界
2、路线不能重复，也就是说每个点只能经过一次

3、走出迷宫的路线是随机生成的，每次生成的路线都应该不一样
4、迷宫的大小可以任意指定，也就是说明二维数组的大小可以随意变化

5、最终生成的迷宫需要打印出来

迷宫实体类MazePoint：

public class MazePoint {
private boolean isVisited = false;
private boolean wallUp = true;
private boolean wallRight = true;
private boolean wallDown = true;
private boolean wallLeft = true;

public boolean isVisited() {
return isVisited;
}
public void setVisited(boolean isVisited) {
this.isVisited = isVisited;
}
public boolean isWallUp() {
return wallUp;
}
public void setWallUp(boolean wallUp) {
this.wallUp = wallUp;
}
public boolean isWallRight() {
return wallRight;
}
public void setWallRight(boolean wallRight) {
this.wallRight = wallRight;
}
public boolean isWallDown() {
return wallDown;
}
public void setWallDown(boolean wallDown) {
this.wallDown = wallDown;
}
public boolean isWallLeft() {
return wallLeft;
}
public void setWallLeft(boolean wallLeft) {
this.wallLeft = wallLeft;
}
}

迷宫类Maze：

import java.util.Random;
import java.util.Scanner;
import java.util.Stack;
public class Maze {
private final static int dirUp = 0;
private final static int dirRight = 1;
private final static int dirDown = 2;
private final static int dirLeft = 3;

private final static int gridWall = 1;
private final static int gridEmpty = 0;
private final static int gridBlind = -1;
private final static int gridPath = 2;

private int width;
private int height;
private MazePoint[][] matrix;
private int[][] maze;

/*
* 构造一个迷宫，初始化迷宫的宽度和高度，同时初始化包含MazePoint的点阵
*/
public Maze(int height, int width) {
this.width = width;
this.height = height;
this.matrix = new MazePoint[height][width];
for (int i=0; i<height; i++)
for (int j=0; j<width; j++)
matrix[i][j] = new MazePoint();
this.maze = new int[2*height+1][2*width+1];  //构建宽为2*height+1、长为2*width+1的迷宫
}

/*
* 检查目标点的上下左右的邻居是否可以被访问，如果目标点超出界限则视为已被访问
*/
public boolean isNeighborOK(int x, int y, int dir) {
boolean isNeighborVisited = false;
switch ( dir ) {
case dirUp:
if ( x <= 0 )
isNeighborVisited = true;  //越界视为已被访问
else
isNeighborVisited = matrix[x-1][y].isVisited();
break;
case dirRight:
if ( y >= width - 1 )
isNeighborVisited = true;
else
isNeighborVisited = matrix[x][y+1].isVisited();
break;
case dirDown:
if ( x >= height - 1 )
isNeighborVisited = true;
else
isNeighborVisited = matrix[x+1][y].isVisited();
break;
case dirLeft:
if ( y <= 0 )
isNeighborVisited = true;
else
isNeighborVisited = matrix[x][y-1].isVisited();
break;
}
return !isNeighborVisited;  //若点未被访问过（isNeighborVisited为false），则返回值为true，表示有邻居可以被访问
}

/*
* 检查目标点的上下左右是否至少有一个可以访问
*/
public boolean isNeighborOK(int x, int y) {
return (this.isNeighborOK(x, y, dirUp) || this.isNeighborOK(x, y, dirRight) ||
this.isNeighborOK(x, y, dirDown) || this.isNeighborOK(x, y, dirLeft));
}

/*
* 获得一个可以被访问的方向
*/
public int getRandomDir(int x, int y) {
int dir = -1;
Random rand = new Random();
if ( isNeighborOK(x, y) ) {
do {
dir = rand.nextInt(4);
} while ( !isNeighborOK(x, y, dir) );  //(x,y)的dir方向不可被访问，重新选择方向
}
return dir;
}

/*
* 将相邻可以访问的点设置为通路
*/
public void pushWall(int x, int y, int dir) {
switch ( dir ) {
case dirUp:
matrix[x][y].setWallUp(false);
matrix[x-1][y].setWallDown(false);  //将该点与其上面相邻的点设置通路
break;
case dirRight:
matrix[x][y].setWallRight(false);
matrix[x][y+1].setWallLeft(false);  //将该点与其右面相邻的点设置通路
break;
case dirDown:
matrix[x][y].setWallDown(false);
matrix[x+1][y].setWallUp(false);  //将该点与其下面相邻的点设置通路
break;
case dirLeft:
matrix[x][y].setWallLeft(false);
matrix[x][y-1].setWallRight(false);  //将该点与其左面相邻的点设置通路
break;
}
}

/*
* 深度优先遍历
*/
public void traversal() {
int x = 0;
int y = 0;
Stack<Integer> stackX = new Stack<Integer>();
Stack<Integer> stackY = new Stack<Integer>();
do {
MazePoint p = matrix[x][y];
if ( !p.isVisited() ) {
p.setVisited(true);
}
if ( isNeighborOK(x, y) ) {
int dir = this.getRandomDir(x, y);  //获得一个随机可访问的方向
this.pushWall(x, y, dir);  //设置通路
stackX.add(x);  //保存坐标信息
stackY.add(y);  //保存坐标信息
switch ( dir ) {
case dirUp:
x--;
break;
case dirRight:
y++;
break;
case dirDown:
x++;
break;
case dirLeft:
y--;
break;
}
}
else {
x = stackX.pop();
y = stackY.pop();
}
} while ( !stackX.isEmpty() );
}

/*
* 根据MazePoint点阵右侧和下侧的墙构建迷宫
*/
public void create() {
//
}

/*
* 打印迷宫
*/
public void print() {
for (int i=0; i<2*height+1; i++) {
for (int j=0; j<2*width+1; j++)
if ( maze[i][j] == gridWall )
System.out.print("□");
else if ( maze[i][j] == gridPath )
System.out.print(".");
adf6
//通路标记为".",其他设置为"□"
else
System.out.print("□");
System.out.println();
}
}

/*
* 在迷宫数组中去获得一个访问的方向
*/
public int getBreakOutDir(int x, int y) {
int dir = -1;
if ( maze[x][y+1] == 0 )
dir = dirRight;
else if ( maze[x+1][y] == 0 )
dir = dirDown;
else if ( maze[x][y-1] == 0 )
dir = dirLeft;
else if ( maze[x-1][y] == 0 )
dir = dirUp;
return dir;
}

/*
* 找到从点 (1, 1) 到点 (2*height-1, 2*width-1) 的一条路径
*/
public void findPath() {
int x = 1;
int y = 1;
Stack<Integer> stackX = new Stack<Integer>();
Stack<Integer> stackY = new Stack<Integer>();
do {
int dir = this.getBreakOutDir(x, y);
if ( dir == -1 ) {
maze[x][y] = gridBlind;  //方向不存在的设置为盲点
x = stackX.pop();
y = stackY.pop();
}
else {
maze[x][y] = gridPath;
stackX.add(x);
stackY.add(y);  //保存通路点坐标信息
switch ( dir ) {
case dirUp:
x--;
break;
case dirRight:
y++;
break;
case dirDown:
x++;
break;
case dirLeft:
y--;
break;
}
}
} while ( !(x == 2*height-1 && y == 2*width-1) );
maze[x][y] = gridPath;
}

/*
* 清除迷宫中的路径
*/
public void reset() {
for (int i=0; i<2*height+1; i++)
for (int j=0; j<2*width+1; j++)
if ( maze[i][j] != gridWall )
maze[i][j] = gridEmpty;
}
}

测试的main类：

public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scanner = new Scanner(System.in);
System.out.println("请输入n:迷宫的行数为2n+1(包括上下两道墙)");
int row = scanner.nextInt();
System.out.println("请输入m:迷宫的列数为2m+1");
int col = scanner.nextInt();
Maze maze = new Maze(row, col);
maze.traversal();  //遍历
maze.create();     //构建迷宫
maze.findPath();   //找到路径
maze.print();     //打印迷宫
maze.reset();     //清除迷宫
}

运行截图：



代码下载链接：完整代码下载