(java)BFS广度优先遍历解决迷宫问题

借鉴博客https://blog.csdn.net/QIANGWEIYUAN/article/details/90375392
从数据结构出发,在java基础上理解BFS
更容易解决迷宫问题

请输入迷宫的行列数:5 5
请输入迷宫路径
0 0 1 1 1 
1 0 0 0 0
1 0 0 0 0
1 1 0 1 1
1 1 0 0 0
迷宫路径搜索结果如下：
* * 1 1 1 
1 * 0 0 0 
1 * * 0 0 
1 1 * 1 1 
1 1 * * *

package suanfa_java;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;


public class 广度优先搜索 {
	
	/**
	 * @param args
	 * Java代码 - 基于广度优先遍历实现迷宫路径搜索(搜索迷宫的最短路径信息)
	 * 通过广度优先遍历，层层向外扩张的方式，可以找到迷宫最优的路径信息，
	 * 借助一个队列实现广度优先遍历层层向外扩张的思想，再借助一个数组打印节点的行走信息，代码运行如下：
	 * 
	 * 	请输入迷宫的行列数:5 5
		请输入迷宫路径
		0 0 1 1 1 
		1 0 0 0 0
		1 0 0 0 0
		1 1 0 1 1
		1 1 0 0 0
		迷宫路径搜索结果如下：
		* * 1 1 1 
		1 * 0 0 0 
		1 * * 0 0 
		1 1 * 1 1 
		1 1 * * * 
	 * @throws IOException 
	 * 
	 * 
	 */
	
	public static void main(String[] args) throws IOException {
	    System.out.print("请输入迷宫的行列数:");
	    int row, col, data;
	    row = Reader.nextInt();
	    col = Reader.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 = Reader.nextInt();
	            maze.initMazeNode(data, i, j);
	        }
	    }

	    // 修改迷宫所有节点四个方向的行走状态信息
	    maze.initMazeNodePathState();
	    // 寻找迷宫路径
	    maze.findMazePath();
	    // 打印迷宫路径搜索的结果
	    maze.showMazePath();
	}

}

//该迷宫采用栈实现非递归路径搜索，可以直接使用Java集合LinkedList，这里是自定义一个链式栈结构，代码如下：

/**
 * 描述:实现迷宫路径搜索需要的链式栈结构
 */
class Stack<T>{
	// top指向头节点，头节点的后面就是栈顶节点
	 private Entry<T> top;
	 
	 public Stack(){
		 this.top = new Entry<>(null,null);
	 }
	 
	 	/**
	     * 入栈操作
	     * @param val
	     */
	 public void push(T val){
		 Entry<T> node = new Entry<>(val, this.top.next);
		 this.top.next = node;
	 }
	 
	 	/**
	     * 出栈操作
	     * @return
	     */
	 public T pop(){
		 T val = null;
		 if (this.top.next != null) {
			val = this.top.next.data;
			this.top.next = this.top.next.next;
		}
		 return val;
	 }
	 
	 	/**
	     * 查看栈顶元素
	     * @return
	     */
	 public T peek(){
		 T val = null;
		 if (this.top.next != null) {
			val = this.top.next.data;
		}
		 return val;
	 }
	 
	 	/**
	     * 判断栈空
	     * @return
	     */
	 public boolean isEmpty(){
		 return this.top.next == null;
	 }
	 
	  	/**
	     * 节点类型定义
	     * @param 
	     */
	 static class Entry<T>{
		 T data;
		 Entry<T> next;
		 
		 public Entry(T data, Entry<T> next) {
			 this.data = data;
			 this.next = next;
		 }
		 
		 
	 }
}

//这里主要包含了迷宫节点类MazeNode和迷宫类型Maze，代码如下：
/**
 * 描述: 迷宫的类型定义
 */
class Maze{
	// 迷宫所有的路径存储在二维数组当中
	private MazeNode[][] maze;
	// 存储迷宫路径节点的队列结构，采用层层扩张的方式，寻找迷宫最优的路径信息
	 private Queue<MazeNode> queue;
	// 迷宫的行数
	 private int row;
	 // 迷宫的列数
	 private int col;
	// 记录迷宫路径节点的行走信息
	 private MazeNode[] pathrecord;
//	 public static final int[] Constant = {0,1,2,3};
	 
	 	/**
		 * 描述: 把代码中所有出现的常量在这里统一定义
		 */
		public interface Constant {
			// 右方向
			int RIGHT = 0;
			// 下方向
			int DOWN = 1;
			// 左方向
			int LEFT = 2;
			// 上方向
			int UP = 3;
		}
	 
	 
	 	/**
	     * 迷宫初始化
	     * @param row
	     * @param col
	     */
	 public Maze(int row, int col) {
	        this.row = row;
	        this.col = col;
	        this.maze = new MazeNode[row][col];
	        this.queue = new LinkedList<Maze.MazeNode>();
	        this.pathrecord = new MazeNode[row*col];
	    }

	    /**
	     * 初始化指定位置的迷宫节点
	     * @param data
	     * @param i
	     * @param j
	     */
	 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++) {
				// 值为1的节点方向状态不用调整，因为走不到
				if (this.maze[i][j].val == 1) {
					continue;
				}
				
				if (j < col - 1 && this.maze[i][j+1].val == 0) {
					this.maze[i][j].state[Constant.RIGHT] = true;
				}
				
				if (i < row - 1 && this.maze[i+1][j].val == 0) {
					this.maze[i][j].state[Constant.DOWN] = true;
				}
				
				if (j>0 && this.maze[i][j-1].val == 0) {
					this.maze[i][j].state[Constant.LEFT] = true;
				}
				
				if (i>0 && this.maze[i-1][j].val == 0) {
					this.maze[i][j].state[Constant.UP] = true;
				}
			}
		}
	 }
	 
	 
	 	/**
	     * 寻找迷宫路径
	     */
	public void findMazePath() {
		if (maze[0][0].val == 1) {
			return;
		}
		
		queue.offer(maze[0][0]);
		while(!queue.isEmpty()){
			MazeNode top = queue.peek();
			int x = top.x;
			int y = top.y;
			
			// 往右方向走
			if (maze[x][y].state[Constant.RIGHT]) {
				maze[x][y].state[Constant.RIGHT] = false;
				maze[x][y + 1].state[Constant.LEFT] = false;
				queue.offer(maze[x][y + 1]);
				pathrecord[x * col + y + 1] = maze[x][y];
				if (check(x, y + 1)) { // 判断是否找到了右下角出口节点，找到的话直接退出
					return;
				}
			}
			
			  // 往下方向走
            if(maze[x][y].state[Constant.DOWN]){
                maze[x][y].state[Constant.DOWN] = false;
                maze[x+1][y].state[Constant.UP] = false;
                queue.offer(maze[x+1][y]);
                pathrecord[(x+1)*col+y] = maze[x][y];
                if(check(x+1, y)){ // 判断是否找到了右下角出口节点，找到的话直接退出
                    return;
                }
            }
            
            
            // 往左方向走
            if(maze[x][y].state[Constant.LEFT]){
                maze[x][y].state[Constant.LEFT] = false;
                maze[x][y-1].state[Constant.RIGHT] = false;
                queue.offer(maze[x][y-1]);
                pathrecord[x*col+y-1] = maze[x][y];
                if(check(x, y-1)){ // 判断是否找到了右下角出口节点，找到的话直接退出
                    return;
                }
            }
            
            // 往上方向走
            if(maze[x][y].state[Constant.UP]){
                maze[x][y].state[Constant.UP] = false;
                maze[x-1][y].state[Constant.DOWN] = false;
                queue.offer(maze[x-1][y]);
                pathrecord[(x-1)*col+y] = maze[x][y];
                if(check(x-1, y)){ // 判断是否找到了右下角出口节点，找到的话直接退出
                    return;
                }
            }
            
            queue.poll();	
		}
	}   
	
	/**
     * 检查是否找到右下角出口的节点
     * @param x
     * @param y
     * @return
     */
    private boolean check(int x, int y) {
        return x == this.row-1 && y == this.col-1;
    }
	
    
    /**
     * 打印迷宫路径搜索的结果
     */
    
    public void showMazePath() {
        System.out.println("迷宫路径搜索结果如下：");
        if(pathrecord[row*col-1] == null){
            System.out.println("迷宫不存在有效路径");
        } else {
            int x = row-1;
            int y = col-1;
            for(;;){
                maze[x][y].val = '*';
                MazeNode node = pathrecord[x*col+y];
                if(node == null){
                    break;
                }
                x = node.x;
                y = 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 static class MazeNode{
		// 节点的值
		int val;
		// 节点的x和y坐标
		int x;
		int y;
		// 节点四个方向的行走状态，true表示可以走，false表示不能走
		boolean[] state;
		 /**
         * 迷宫路径初始化
         * @param data
         * @param i
         * @param j
         */
		public MazeNode(int data, int i, int j){
			this.state = new boolean[4];
			this.val = data;
			this.x = i;
			this.y = j;
		}
		
	}
	
}

class Reader{
	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static StringTokenizer tokenizer = new StringTokenizer("");
	static String next() throws IOException{
		while (!tokenizer.hasMoreTokens()) {
			tokenizer = new StringTokenizer(br.readLine());
		}
		return tokenizer.nextToken() ;
	}
	
	static int nextInt() throws  IOException{
		return Integer.parseInt(next());
	}
	
	static String nextLine() throws  IOException{
		return br.readLine();
	}
}