算法第三讲（使用队列走迷宫 广度优先）

算法第三讲（使用队列走迷宫 广度优先）

从2019年9月开始，会把《数据结构》经典的算法介绍一遍。加油，89lovelc

问题介绍

有一个迷宫，如图是这样的，我们从A点出发，是否能够找到一条路找到B点，如果有请打出走的路径。

问题分析

• 处理迷宫问题，现实生活中我们可以使用右手法则尽心。 如果就是一直靠右边的墙走就行。这种也可以使用电脑解决，常用的有两种方式分别是深度优先和广度优先，今天要讲的是广度优先。
• 1）当我们进入到迷宫的时候，我们有4个方向可以走，上下左右，自己走过来的路不在走了。
• 2）然后我们在遍历第二层
• 
• 如图一层一层的遍历，遇到墙壁或者走过的路就不进行走。

算法思想

• 画迷宫
  • 我们使用二维数组进行画迷宫，1代表墙，0代表路
• 创建节点代码
  • 创建node对象，里面存放坐标index和前驱节点的值（用于反向查找路线，或者找出迷宫的路）
• 创建队列
  • 创建队列进行存放节点，存入入口节点
  • 队列出站，拿到节点，将节点标记为2,表示已经走过了，将该节点进行上下左右的计算得到新的四个节点，判断是否符合规则，符合规则进入队列，并标记为2
  • 队列出队，直到出队节点是出口节点或者为空为止

代码实现

public class Node {

    public int x;

    public int y;

    public Node pre;


    public Node(int x, int y, Node pre) {
        this.x = x;
        this.y = y;
        this.pre = pre;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Node node = (Node) o;
        return x == node.x &&
                y == node.y;
    }

    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }
}

public class QueueMaze {


    static int[][] arr = {
            {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
            {0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1},
            {1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1},
            {1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1},
            {1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1},
            {1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1},
            {1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1},
            {1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1},
            {1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1},
            {1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1},
            {1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1},
            {1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1},
            {1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1},
            {1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1},
            {1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1},
            {1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1},
            {1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1},
            {1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1},
            {1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0},
            {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}
    };


    public static void print(int arr1[][]) {            //打印地图的方法
        for (int i = 0; i < arr1.length; i++) {
            for (int j = 0; j < arr1[i].length; j++) {
                if (arr1[i][j] == 1) {
                    System.out.print("▇" + "\t");
                } else if (arr1[i][j] == 3) {
                    System.out.print("*" + "\t");
                } else {
                    System.out.print("  " + "\t");
                }
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        Node start = new Node(1, 0, null);
        Node end = new Node(18, 19, null);

        Node path = findPath(start, end);

        Node pre = path;
        while (pre != null) {
            arr[pre.x][pre.y] = 3;
            pre = pre.pre;
        }

        print(arr);
    }


    static public Node findPath(Node start, Node end) {

        //进行放入的队列
        Queue<Node> nodes = new LinkedList<Node>();

        //进入队列 里面的都进行标记 标记的都是为 2
        arr[start.x][start.y] = 2;
        nodes.offer(start);


        while (true) {
            //出队列 判断是否是end节点
            Node poll = nodes.poll();
            //如果是最后 跳出
            if (Objects.equals(poll, end)) {
                return poll;
            }

            //为空就是找不到 end
            if (Objects.isNull(poll)) {
                return null;
            }

            //得到该队列的上下左右的节点进入队列中
            //上
            Node node = existNode(poll.x - 1, poll.y, poll);
            if (Objects.nonNull(node)) {
                nodes.offer(node);
            }

            //下
            node = existNode(poll.x + 1, poll.y, poll);
            if (Objects.nonNull(node)) {
                nodes.offer(node);
            }

            //左
            node = existNode(poll.x, poll.y - 1, poll);
            if (Objects.nonNull(node)) {
                nodes.offer(node);
            }

            //右
            node = existNode(poll.x, poll.y + 1, poll);
            if (Objects.nonNull(node)) {
                nodes.offer(node);
            }

        }

    }

    static private Node existNode(int x, int y, Node node) {
        
        //判断x y所构成的节点是否合法
        if (x >= 0 && x <= 19
                && y >= 0 && y <= 19
                && arr[x][y] == 0) {
            arr[x][y] = 2;
            return new Node(x, y, node);
        }

        return null;
    }


}

运行结果

总结

• 进行广度优先的意思，就是一层一层的遍历，使用队列进行实现，因为是一层一层的遍历，纵向优先所以称之为广度优先。