package Queue;
import java.util.Arrays;
import java.util.Scanner;
public class findPathDemo02 {
/**
* 定义迷宫节点类型
*/
private static class MazeNode {
// 节点的值
int val;
// 节点的x和y坐标
int x;
int y;
// 节点四个方向的行走状态,true表示可以走,false表示不能走
boolean[] state;
/**
* 迷宫路径初始化
*/
public MazeNode(int data, int i, int j){
this.state = new boolean[4]; //上下左右四个状态!
this.val = data; //每一个点的数值 表示可不可以行走!
this.x = i; //在迷宫中的对应的坐标值
this.y = j;
}
@Override
public String toString() {
return "MazeNode{" +
"val=" + val +
", x=" + x +
", y=" + y +
", state=" + Arrays.toString(state) +
'}';
}
}
/**
* 描述: 迷宫的类型定义
*/
public static class Maze {
// 迷宫所有的路径存储在二维数组当中
private MazeNode[][] maze;
// 存储迷宫路径节点的队列结构,采用层层扩张的方式,寻找迷宫最优的路径信息
private LinkQueue<MazeNode> queue;
// 记录迷宫路径节点的行走信息
private MazeNode[] pathrecord;
// 迷宫的行数
private int row;
// 迷宫的列数
private int col;
/**
* 迷宫初始化
*/
public Maze(int row, int col) {
this.row = row;
this.col = col;
this.maze = new MazeNode[row][col]; //初始化棋盘
this.queue=new LinkQueue<>(); //创建一个队列用于扩张
this.pathrecord = new MazeNode[row*col]; //创建一个数组用来存放可能经过的路径信息
}
/**
* 初始化指定位置的迷宫节点
*/
public void initMazeNode(int data, int i, int j) {
this.maze[i][j] = new MazeNode(data, i, j);
}
/**
* 修改迷宫所有节点四个方向的行走状态信息
*/
public void initMazeNodePathState() {
for (int i=0;i<row;i++){
for (int j=0;j<col;j++){
if(j+1<col&&maze[i][j+1].val==0){
maze[i][j].state[Constant.RIGHT]=true; //上下左右 如果值为0 则表示可以走 如果不是就不能走
}
if(i+1<row&&maze[i+1][j].val==0){
maze[i][j].state[Constant.DOWN]=true;
}
if(j>0&&maze[i][j-1].val==0){
maze[i][j].state[Constant.LEFT]=true;
}
if(i>0&&maze[i-1][j].val==0){
maze[i][j].state[Constant.UP]=true;
}
}
}
}
/**
* 寻找迷宫路径
*/
static int count=0;
public void findMazePath(int beginx,int beginy) {
if (maze[beginx][beginy].val != 0) {
return; //默认初始的时候为00
}
queue.Insert(maze[beginx][beginy]); //首先将它存入队列中
while(!queue.isEmpty()){
MazeNode top = queue.peek();
int x = top.x;
int y = top.y; //判断是不是终点!
if(x == row-1 && y == col-1){
return;
}
// 往右方向走
if(maze[x][y].state[Constant.RIGHT]){
maze[x][y].state[Constant.RIGHT] = false; //走过的路不能再走
maze[x][y+1].state[Constant.LEFT] = false;
queue.Insert(maze[x][y+1]);
pathrecord[x*col+y+1] = maze[x][y]; //将二维数组存放到一维数组中 按行存储
System.out.println(++count+"次右 "+x+" "+y);
}
// 往下方向走
if(maze[x][y].state[Constant.DOWN]){
maze[x][y].state[Constant.DOWN] = false;
maze[x+1][y].state[Constant.UP] = false;
queue.Insert(maze[x+1][y]);
pathrecord[(x+1)*col+y] = maze[x][y];
System.out.println(++count+"次下 "+x+" "+y);
}
// 往左方向走
if(maze[x][y].state[Constant.LEFT]){
maze[x][y].state[Constant.LEFT] = false;
maze[x][y-1].state[Constant.RIGHT] = false;
queue.Insert(maze[x][y-1]);
pathrecord[x*col+y-1] = maze[x][y];
System.out.println(++count+"次左 "+x+" "+y);
}
// 往上方向走
if(maze[x][y].state[Constant.UP]){
maze[x][y].state[Constant.UP] = false;
maze[x-1][y].state[Constant.DOWN] = false;
queue.Insert(maze[x-1][y]);
pathrecord[(x-1)*col+y] = maze[x][y];
System.out.println(++count+"次上 "+x+" "+y);
}
queue.poll();
}
}
/**
* 打印迷宫路径搜索的结果
*/
public void showMazePath(){
if(pathrecord[row*col-1] == null){
System.out.println("迷宫不存在有效路径");
} else {
int a = row-1;
int b = col-1;
System.out.println("====================");
while(true){
maze[a][b].val = '*';
MazeNode node = pathrecord[a*col+b];
System.out.println(a+" "+b);
if(node == null){
System.out.println("==");
break;
}
a = node.x;
b = node.y;
}
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
if(maze[i][j].val == '*'){
System.out.print('*' + " ");
} else {
System.out.print(maze[i][j].val + " ");
}
}
System.out.println();
}
}
}
/**
* 描述: 定义迷宫节点类型
*/
private class MazeNode {
// 节点的值
int val;
// 节点的x和y坐标
int x;
int y;
// 节点四个方向的行走状态,true表示可以走,false表示不能走
boolean[] state;
/**
* 迷宫路径初始化
j
*/
public MazeNode(int data, int i, int j){
this.state = new boolean[4];
this.val = data;
this.x = i;
this.y = j;
}
}
}
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.print("请输入迷宫的行列数:");
int row, col, data;
row = in.nextInt();
col = in.nextInt();
Maze maze = new Maze(row, col);
System.out.println("请输入迷宫路径");
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
data = in.nextInt();
maze.initMazeNode(data, i, j);
}
}
// 修改迷宫所有节点四个方向的行走状态信息
maze.initMazeNodePathState();
// 寻找迷宫路径
System.out.println("请输入你想要开始的起始位置的下标:");
int beginx=in.nextInt();
int beginy=in.nextInt();
maze.findMazePath(beginx,beginy);
// 打印迷宫路径搜索的结果
maze.showMazePath();
}
}
/*
0 1 0 0 0
0 0 0 1 0
1 0 1 1 0
0 0 0 0 0
0 0 0 0 0
*/
/*
0 0 0 0 0 0 0 0 0 0
1 1 0 0 1 0 1 0 1 0
1 0 0 0 0 0 0 1 0 1
0 0 1 1 0 0 1 0 1 0
0 0 1 0 0 0 0 1 0 1
0 0 0 1 0 0 1 0 1 1
0 0 0 0 0 1 0 1 0 1
0 0 0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0 0 0
0 0 0 1 0 1 0 0 0 0
*/
使用自己写的链队列!
package Queue;
public class LinkQueue<T> {
// 指向头节点(队头)
private Entry<T> front;
// 指向尾节点(队尾)
private Entry<T> rear;
// 记录队列节点的个数
private int count;
/**
* 初始化,front和rear都指向头节点
*/
public LinkQueue(){
this.front = this.rear = new Entry<>(null, null); //新建的结点为空!
}
/**
* 入队操作
*/
public void Insert(T val){
Entry<T> node = new Entry<>(val, null);
this.rear.next = node; //将现有的尾指针的值指向新的结点! 连接操作!
this.rear = node; //将现在的尾指针所指方向更新到最末尾的结点也就是本身的结点!
this.count++; //链队的加长度加操作!
}
/**
* 出队操作
*/
public T poll(){
T val = null; //创建一个泛型用来存放出队的数据!
if(this.front.next != null){
val = this.front.next.data; //取出数据
this.front.next = this.front.next.next; //更新头指针的指向方向!
// 删除队列最后一个元素,要把rear指向front,队列才能判空
if(this.front.next == null){
this.rear = this.front; //出队如果是最后一个元素所需要的判断!
}
this.count--;
}
return val;
}
/**
*取对头操作!(只查看 不取值)
*/
public T peek(){
T val = null;
if(this.front.next != null){
val = this.front.next.data;
}
return val;
}
/**
* 判断队列空
*/
public boolean isEmpty(){
return this.front == this.rear;
}
/**
* 返回队列元素的个数
*/
public int size(){
return this.count;
}
/**
* 节点类型定义
*/
static class Entry<T>{
T data; //一个是数据域
Entry<T> next; //一个是指针 指向下一个元素
public Entry(T data, Entry<T> next) { //初始化条件为数据和指向指针
this.data = data;
this.next = next;
}
}
}