在Java中使用二维数组生成迷宫

精选原创

AuraLife 2024-08-15 10:16:04 博主文章分类：综合 ©著作权

文章标签 深度优先搜索 Java 二维数组 文章分类 Java 后端开发 yyds干货盘点

©著作权归作者所有：来自51CTO博客作者AuraLife的原创作品，请联系作者获取转载授权，否则将追究法律责任

一、简介

迷宫是一种有趣且经典的计算机科学问题，通过使用二维数组可以简便地实现迷宫生成。本文将详细说明如何在Java中使用二维数组生成迷宫，并展示迷宫生成的过程。

二、准备工作

在开始编码之前，确保你已经设置好了Java编译环境。本文不涉及外部库，所有操作均使用标准Java库完成。

三、迷宫生成算法概述

深度优先搜索（DFS）

一种有效的迷宫生成方法是使用深度优先搜索（Depth-First Search, DFS）。这种算法通过递归地访问每一个未访问过的单元来生成迷宫。具体步骤如下：

选择一个起始点，将其标记为已访问。
从当前单元随机选择一个未访问的邻居单元。
移除当前单元和该邻居单元之间的墙壁，并将邻居单元标记为已访问。
递归地应用以上步骤直到所有单元都已访问。

四、实现迷宫生成

创建迷宫结构

首先，我们需要初始化一个二维数组来表示迷宫，并设置墙壁和路径。

import java.util.*;

public class MazeGenerator {
    private static final int WALL = 1;
    private static final int PATH = 0;
    private int rows, cols;
    private int[][] maze;
    private Random rand = new Random();

    public MazeGenerator(int rows, int cols) {
        this.rows = rows;
        this.cols = cols;
        this.maze = new int[rows][cols];
        initializeMaze();
    }

    private void initializeMaze() {
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                maze[i][j] = WALL;
            }
        }
    }
}

使用深度优先搜索生成迷宫

接下来，使用深度优先搜索算法生成迷宫。

public void generateMaze() {
    Stack<int[]> stack = new Stack<>();
    int startX = rand.nextInt(rows / 2) * 2;
    int startY = rand.nextInt(cols / 2) * 2;

    maze[startX][startY] = PATH;
    stack.push(new int[]{startX, startY});

    while (!stack.isEmpty()) {
        int[] current = stack.peek();
        int x = current[0];
        int y = current[1];

        int[][] neighbors = {
            {x + 2, y}, {x - 2, y},
            {x, y + 2}, {x, y - 2}
        };

        List<int[]> unvisitedNeighbors = new ArrayList<>();
        for (int[] neighbor : neighbors) {
            int nx = neighbor[0];
            int ny = neighbor[1];
            if (isValid(nx, ny) && maze[nx][ny] == WALL) {
                unvisitedNeighbors.add(neighbor);
            }
        }

        if (!unvisitedNeighbors.isEmpty()) {
            int[] next = unvisitedNeighbors.get(rand.nextInt(unvisitedNeighbors.size()));
            int nx = next[0];
            int ny = next[1];

            maze[nx][ny] = PATH;
            maze[x + (nx - x) / 2][y + (ny - y) / 2] = PATH;

            stack.push(next);
        } else {
            stack.pop();
        }
    }
}

private boolean isValid(int x, int y) {
    return x >= 0 && y >= 0 && x < rows && y < cols;
}

五、打印和测试迷宫

要打印生成的迷宫，可以创建一个方法来输出迷宫结构。

public void printMaze() {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            System.out.print(maze[i][j] == WALL ? "#" : " ");
        }
        System.out.println();
    }
}

public static void main(String[] args) {
    int rows = 21; // 确保行数为奇数
    int cols = 21; // 确保列数为奇数
    MazeGenerator generator = new MazeGenerator(rows, cols);
    generator.generateMaze();
    generator.printMaze();
}

现在我们可以看到整个类的完整代码如下：

import java.util.*;

public class MazeGenerator {
    private static final int WALL = 1;
    private static final int PATH = 0;
    private int rows, cols;
    private int[][] maze;
    private Random rand = new Random();

    public MazeGenerator(int rows, int cols) {
        this.rows = rows;
        this.cols = cols;
        this.maze = new int[rows][cols];
        initializeMaze();
    }

    private void initializeMaze() {
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                maze[i][j] = WALL;
            }
        }
    }

    public void generateMaze() {
        Stack<int[]> stack = new Stack<>();
        int startX = rand.nextInt(rows / 2) * 2;
        int startY = rand.nextInt(cols / 2) * 2;

        maze[startX][startY] = PATH;
        stack.push(new int[]{startX, startY});

        while (!stack.isEmpty()) {
            int[] current = stack.peek();
            int x = current[0];
            int y = current[1];

            int[][] neighbors = {
                {x + 2, y}, {x - 2, y},
                {x, y + 2}, {x, y - 2}
            };

            List<int[]> unvisitedNeighbors = new ArrayList<>();
            for (int[] neighbor : neighbors) {
                int nx = neighbor[0];
                int ny = neighbor[1];
                if (isValid(nx, ny) && maze[nx][ny] == WALL) {
                    unvisitedNeighbors.add(neighbor);
                }
            }

            if (!unvisitedNeighbors.isEmpty()) {
                int[] next = unvisitedNeighbors.get(rand.nextInt(unvisitedNeighbors.size()));
                int nx = next[0];
                int ny = next[1];

                maze[nx][ny] = PATH;
                maze[x + (nx - x) / 2][y + (ny - y) / 2] = PATH;

                stack.push(next);
            } else {
                stack.pop();
            }
        }
    }

    private boolean isValid(int x, int y) {
        return x >= 0 && y >= 0 && x < rows && y < cols;
    }

    public void printMaze() {
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                System.out.print(maze[i][j] == WALL ? "#" : " ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        int rows = 21; // 确保行数为奇数
        int cols = 21; // 确保列数为奇数
        MazeGenerator generator = new MazeGenerator(rows, cols);
        generator.generateMaze();
        generator.printMaze();
    }
}