Java迷宮代碼，廣度優先遍歷，最短路徑

使用一個隊列，采用層層擴張的方式，尋找迷宮最優的路徑信息，再用一個迷宮節點數組記錄行走信息
方向常量定義：

public interface Constant { // 右方向
    int RIGHT = 0; // 下方向
    int DOWN = 1; // 左方向
    int LEFT = 2; // 上方向
    int UP = 3; }

所用到的鏈式隊列定義(jdk自帶的隊列或集合也可以實現此功能)

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); } /** * 入隊操作 * @param val */
    public void offer(T val){ Entry<T> node = new Entry<>(val, null); this.rear.next = node; this.rear = node; this.count++; } /** * 出隊操作 * @return
     */
    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; } /** * 判斷隊列空 * @return
     */
    public boolean isEmpty(){ return this.front == this.rear; } /** * 返回隊列元素的個數 * @return
     */
    public int size(){ return this.count; } /** * 節點類型定義 * @param <T> */
    static class Entry<T>{ T data; Entry<T> next; public Entry(T data, Entry<T> next) { this.data = data; this.next = next; } } }

源代碼

 /**
     * 描述: 定義迷宮節點類型
     */
    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;
        }
    }
源代碼

/**
 * 描述: 迷宮的類型定義
 *
 * @Author shilei
 * @Date 2019/5/18
 */
public class Maze {
    // 迷宮所有的路徑存儲在二維數組當中
    private MazeNode[][] maze;
    // 存儲迷宮路徑節點的隊列結構，采用層層擴張的方式，尋找迷宮最優的路徑信息
    private LinkQueue<MazeNode> queue;
    // 記錄迷宮路徑節點的行走信息
    private MazeNode[] pathrecord;
    // 迷宮的行數
    private int row;
    // 迷宮的列數
    private int col;

    /**
     * 迷宮初始化
     * @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 LinkQueue<>();
        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++){
                if(j+1<col&&maze[i][j+1].val==0){
                    maze[i][j].state[Constant.RIGHT]=true;
                }
                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;
                }
            }
        }
    }

    /**
     * 尋找迷宮路徑
     */
    public void findMazePath() {
        if (maze[0][0].val != 0) {
            return;
        }
                queue.offer(maze[0][0]);
        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.offer(maze[x][y+1]);
                pathrecord[x*col+y+1] = maze[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.offer(maze[x+1][y]);
                pathrecord[(x+1)*col+y] = maze[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.offer(maze[x][y-1]);
                pathrecord[x*col+y-1] = maze[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.offer(maze[x-1][y]);
                pathrecord[(x-1)*col+y] = maze[x][y];
            }

            queue.poll();
        }
    }
    /**
     * 打印迷宮路徑搜索的結果
     */
    public void showMazePath(){

        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;
        }
    }
}

測試類

public class Main { 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(); // 尋找迷宮路徑
 maze.findMazePath(); // 打印迷宮路徑搜索的結果
 maze.showMazePath(); } }

結果：

請輸入迷宮的行列數:4 5 請輸入迷宮路徑 0  1  0  0 0
0  0  0  1 0
1  0  1  1 0
0  0  0  0 0

* 1 0 0 0 
* * 0 1 0 
1 * 1 1 0 
0 * * * *