java 通过广度优先算法实现走迷宫

最新推荐文章于 2025-09-12 17:22:06 发布

原创最新推荐文章于 2025-09-12 17:22:06 发布 · 435 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #数据结构

本文介绍了如何使用Java通过广度优先算法解决迷宫问题，涉及数据初始化、点位类定义、区域划分、路径探索和核心走迷宫代码。作者详细展示了如何模拟迷宫数据、检查边界条件、跟踪路径和更新步数矩阵。

一直低头写业务代码，对算法也有一些忘记，最近在网上也看了一些资料，通过广度优先算法实现走迷宫。

java:

一步：模拟一些数据

private static int[][] getDate() {

    int[][] maze = new int[6][8];

    String s1 = "0 1 0 0 0 1 0 0";
    String s2 = "0 0 0 0 0 1 0 0";
    String s3 = "0 1 0 0 0 1 0 0";
    String s4 = "0 1 0 0 0 0 0 0";
    String s5 = "0 1 0 0 0 1 0 0";
    String s6 = "0 1 0 0 0 1 0 0";

    for (int i = 0; i < 6; i++) {
        switch (i) {
            case 0:
                maze[i] = getStrtoNum(s1);
                break;
            case 1:
                maze[i] = getStrtoNum(s2);
                break;
            case 2:
                maze[i] = getStrtoNum(s3);
                break;
            case 3:
                maze[i] = getStrtoNum(s4);
                break;
            case 4:
                maze[i] = getStrtoNum(s5);
                break;
            case 5:
                maze[i] = getStrtoNum(s6);
                break;
        }
    }
    return maze;
}

private static int[] getStrtoNum(String str) {
    String[] strArr = str.split(" ");
    int[] t = new int[strArr.length];
    for (int i = 0; i < t.length; i++) {
        t[i] = Integer.parseInt(strArr[i]);
    }
    return t;
}

定义点位的内部类：

static class point {
    private int i;
    private int j;

    public point(int i, int j) {
        this.i = i;
        this.j = j;
    }

    public int getI() {
        return i;
    }

    public void setI(int i) {
        this.i = i;
    }

    public int getJ() {
        return j;
    }

    public void setJ(int j) {
        this.j = j;
    }

    public boolean compare(point p) {
        if (this.i == p.i && this.j == p.j) return true;
        return false;
    }
}

//区域，这里特别重要，代码着当前点的上、左、下、右四个点，在跑代码时是以此四个点位进行上、左、下右逐步向外扩散的，四个基础点位

private static LinkedList<point> dirs;

static {
    dirs = new LinkedList<>();
    dirs.add(new point(-1, 0));
    dirs.add(new point(0, -1));
    dirs.add(new point(1, 0));
    dirs.add(new point(0, 1));

}

// 这个是获取当前点位时，加上基础点位后的偏移点位，返回的点位是要探索的点位

private static point add(point cur, point dir) {
    return new point(cur.getI() + dir.getI(), cur.getJ() + dir.getJ());
}

// 这里是返回探索的点位，是否已经走，是否在迷宫之外，以及当前点位的值是多少

private static Map<String, Object> at(int[][] maze, point next) {


    Map<String, Object> map = new HashMap<>();

    if (next.i < 0 || next.i >= maze.length) {
        map.put("val", 0);
        map.put("flag", false);
    } else if (next.j < 0 || next.j >= maze[next.i].length) {
        map.put("val", 0);
        map.put("flag", false);
    } else {
        try {
            map.put("val", maze[next.i][next.j]);
            map.put("flag", true);
        } catch (ArrayIndexOutOfBoundsException e) {
            e.printStackTrace();
        }

    }
    return map;
}

// 走迷宫的业务代码，

private static int[][] walk(int[][] maze, point start, point end) {

    int[][] steps = new int[maze.length][maze[0].length];

    LinkedList<point> Q = new LinkedList<>();
    Q.offer(start);

    point next;

    while (Q.size() > 0) {
        point cur = Q.pollFirst();
        // 判断当前点位是为是结束点位
        if (cur.compare(end)) break;

        for (point dir : dirs) {

            next = add(cur, dir);

            Map<String, Object> result = at(maze, next);
            // 当前点位，是否允许走
            if (Integer.parseInt(result.get("val").toString()) == 1 || !Boolean.parseBoolean(result.get("flag").toString())) {
                continue;
            }
            //判断当前点位，是否已经被走无
            result = at(steps, next);
            if (Integer.parseInt(result.get("val").toString()) != 0 || !Boolean.parseBoolean(result.get("flag").toString())) {
                continue;
            }
            //判断当前点位是否是开始点位
            if (start.compare(next)) {
                continue;
            }

            // 当前位置的数据值
            result = at(steps, cur);

            steps[next.i][next.j] = Integer.parseInt(result.get("val").toString()) + 1;

            Q.offer(next);
        }
    }
    return steps;

}

// 入口函数

public static void main(String[] args) {
    // write your code here
    int[][] maze = getDate();
       // 迷宫入口是从那个点开始
    point start = new point(0, 0);
    // 迷宫结束点
    point end = new point(maze.length - 1, maze[0].length);

    int[][] steps = walk(maze, start, end);
    for (int i = 0; i < steps.length; i++) {
        for (int j = 0; j < steps[i].length; j++) {
            System.out.printf("%3d", steps[i][j]);
        }
        System.out.println();
    }
}

输入结果：

0 0 4 5 6 0 12 13
1 2 3 4 5 0 11 12
2 0 4 5 6 0 10 11
3 0 5 6 7 8 9 10
4 0 6 7 8 0 10 11
5 0 7 8 9 0 11 12