图相关算法（二）：无向无权图的广度优先遍历（BFS）-非递归版本

最新推荐文章于 2025-03-15 00:00:00 发布

技术人爱思考

最新推荐文章于 2025-03-15 00:00:00 发布

阅读量1.2k

点赞数

CC 4.0 BY-SA版权

分类专栏： Java 算法

本文链接：https://blog.youkuaiyun.com/wanxu12345678910/article/details/83186585

Java 同时被 2 个专栏收录

9 篇文章

订阅专栏

算法

3 篇文章

订阅专栏

本文介绍了一种使用邻接表存储结构的无向无权图的广度优先搜索(BFS)算法实现。通过HashSet记录已访问节点，利用队列更新并存放待访问子节点。示例代码展示了如何构建图结构并执行BFS遍历。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

核心

采用邻接表作为图数据的存储结构
对访问过的节点进行记录，文中采用HashSet实现
采用队列存放未访问的子节点，不断更新队列
BFS采用队列实现很简单，采用递归反而更复杂了

本文建立的图结构如下：
在这里插入图片描述

实现代码如下：

package algorithms;

import java.util.*;

/**
 * Created by Json Wan on 2018/10/19.
 * 无向无权图的广度优先遍历
 * 存储结构：邻接表
 */
public class GraphBFS {

    static class Node {
        int name;
        List<Node> neighbors = new ArrayList<>();

        public Node(int name) {
            this.name = name;
        }

        public void addNeighbor(Node node) {
            neighbors.add(node);
        }

        @Override
        public String toString() {
            return "node"+name;
        }
    }

    public static List<Node> bfs(Node rootNode) {
        List<Node> result = new ArrayList<>();
        Set<Node> visitedNodes=new HashSet<>();
        Queue<Node> queue=new LinkedList<>();
        queue.add(rootNode);
        while(!queue.isEmpty()){
            Node node=queue.poll();
            if(!visitedNodes.contains(node)){
                result.add(node);
                visitedNodes.add(node);
                node.neighbors.stream().forEach(queue::add);
            }
        }
        return result;
    }


    public static void main(String[] args) {
        //初始化节点
        Node node1 = new Node(1);
        Node node2 = new Node(2);
        Node node3 = new Node(3);
        Node node4 = new Node(4);
        Node node5 = new Node(5);
        Node node6 = new Node(6);
        //建立连接//node1
        node1.addNeighbor(node2);
        node1.addNeighbor(node3);
        node1.addNeighbor(node4);
        node1.addNeighbor(node5);
        //node2
        node2.addNeighbor(node1);
        node2.addNeighbor(node4);
        node2.addNeighbor(node5);
        //node3
        node3.addNeighbor(node1);
        node3.addNeighbor(node4);
        node3.addNeighbor(node5);
        //node4
        node4.addNeighbor(node1);
        node4.addNeighbor(node2);
        node4.addNeighbor(node3);
        node4.addNeighbor(node6);
        //node5
        node5.addNeighbor(node1);
        node5.addNeighbor(node2);
        node5.addNeighbor(node3);
        node5.addNeighbor(node6);
        //node6
        node6.addNeighbor(node4);
        node6.addNeighbor(node5);
        //BFS算法
        List<Node> bfsPath = bfs(node1);
        for (Node node : bfsPath)
            System.out.print(node.name + " ");
    }
}

运行结果：
1 2 3 4 5 6