java队列实现迷宫寻路

可以使用队列实现迷宫寻路算法，以下是一个简单的 Java 实现：

import java.util.LinkedList;
import java.util.Queue;

public class MazeSolver {

    // 迷宫地图
    private int[][] maze;
    // 起点和终点坐标
    private int startX, startY, endX, endY;
    // 方向数组，用于在迷宫中移动
    private int[][] dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
    // 标记数组，用于标记每个位置是否已经访问过
    private boolean[][] visited;
    // 队列，用于存储要遍历的位置
    private Queue<int[]> queue;

    public MazeSolver(int[][] maze, int startX, int startY, int endX, int endY) {
        this.maze = maze;
        this.startX = startX;
        this.startY = startY;
        this.endX = endX;
        this.endY = endY;
        this.visited = new boolean[maze.length][maze[0].length];
        this.queue = new LinkedList<>();
    }

    // 判断一个位置是否合法，即是否在迷宫范围内，且没有障碍物，且没有被访问过
    private boolean isValid(int x, int y) {
        int rows = maze.length;
        int cols = maze[0].length;
        return x >= 0 && x < rows && y >= 0 && y < cols && maze[x][y] == 0 && !visited[x][y];
    }

    // 寻找迷宫的出口
    public void solve() {
        // 将起点加入队列
        queue.offer(new int[]{startX, startY});

        while (!queue.isEmpty()) {
            // 取出队列中的第一个位置
            int[] curr = queue.poll();
            int x = curr[0], y = curr[1];

            // 如果当前位置是终点，就退出循环
            if (x == endX && y == endY) {
                break;
            }

            // 将当前位置标记为已访问
            visited[x][y] = true;

            // 将当前位置的四个方向加入队列（如果方向合法）
            for (int[] dir : dirs) {
                int nextX = x + dir[0];
                int nextY = y + dir[1];
                if (isValid(nextX, nextY)) {
                    queue.offer(new int[]{nextX, nextY});
                }
            }
        }

        // 打印路径
        printPath();
    }

    // 打印路径
    private void printPath() {
        if (!visited[endX][endY]) {
            System.out.println("没有找到出口！");
            return;
        }

        int x = endX, y = endY;
        while (x != startX || y != startY) {
            System.out.printf("(%d,%d) -> ", x, y);
            for (int[] dir : dirs) {
                int prevX = x - dir[0];
                int prevY = y - dir[1];
                if (isValid(prevX, prevY) && visited[prevX][prevY]) {
                    x = prevX;
                    y = prevY;
                    break;
                }
            }
        }
        System.out.printf("(%d,%d)\n", startX, startY);
    }

    public static void main(String[] args) {
        int[][] maze = {
            {0, 1, 0, 0, 0},
            {0, 1, 0, 1, 0},
            {0, 0, 0, 0, 0},
            {1, 1, 1, 1, 0},
            {0, 0, 0, 0, 0},
        };
        MazeSolver solver = new MazeSolver(maze, 0, 0, 4, 4);
        solver.solve();
    }
}

这个实现使用 BFS 算法来遍历迷宫，从起点开始，每次将当前位置的四个方向加入队列（如果方向合法），然后取出队列中的第一个位置，并将其标记为已访问。如果当前位置是终点，则退出循环。最后打印路径。