【笔记】学习深度优先遍历（DFS）和广度优先遍历（BFS）

移动开发 2023-07-16 02:05:36 阅读次数: 0

前言：

最近在项目中开发了一个组织树的功能，正好使用了深度优先遍历和广度优先遍历进行结点遍历，觉得非常有意思这里做一下笔记记录一下。

提示：部门表设计可以查看以下链接：
MYSQL8使用CTE实现递归遍历

深度优先遍历（DFS）

定义：

深度优先遍历全称叫Depth First Search（简称DFS），例如查询一棵树从顶级节点往下找所有子节点，深度优先遍历会一条路走到底，直到遇到“死胡同”才会返回到i上一节点（回溯），如果上一节点没有其他路可以探索，则会继续原路返回探索别的路线，直到遍历完最后退出。

在这里插入图片描述
回溯之后从上一节点依次递推继续探索，最终路线图如下：
在这里插入图片描述

项目应用

一、项目需求：

组织架构功能，公司下还有多个部门，每个部门下有对应的员工，要求展示公司部门关系以及部门与员工的关系，要求将整个公司的组织架构下所有的结构和员工返回，一个公司组织架构如下：
在这里插入图片描述

二、设计思路

先构建部门树形关系，再查询所有员工根据部门进行分组，使用深度优先遍历DFS挂载每个部门下的所有员工。以下是部门和员工表结构设计和表数据：

1.创建用户表user_info结构和数据

CREATE TABLE `user_info`  (
  `id` bigint NOT NULL COMMENT '主键ID',
  `name` varchar(30) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT '' COMMENT '姓名',
  `department_id` bigint NULL DEFAULT 0 COMMENT '部门id',
  `delete_flag` int NULL DEFAULT 0,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_unicode_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of user_info
-- ----------------------------
INSERT INTO `user_info` VALUES (0, 'Jerry', 4, 0);
INSERT INTO `user_info` VALUES (1, 'Jone', 1, 0);
INSERT INTO `user_info` VALUES (2, 'Jack', 1, 0);
INSERT INTO `user_info` VALUES (3, 'Tom', 2, 0);
INSERT INTO `user_info` VALUES (4, 'Sandy', 3, 0);
INSERT INTO `user_info` VALUES (5, 'Billie', 4, 0);

SET FOREIGN_KEY_CHECKS = 1;

在这里插入图片描述

2.创建部门表department结构和数据

CREATE TABLE `department`  (
  `id` bigint NOT NULL AUTO_INCREMENT,
  `name` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT '' COMMENT '部门名称',
  `parent_id` bigint NULL DEFAULT NULL,
  `create_time` datetime(0) NULL DEFAULT NULL,
  `update_time` datetime(0) NULL DEFAULT CURRENT_TIMESTAMP(0) ON UPDATE CURRENT_TIMESTAMP(0),
  `delete_flag` int NULL DEFAULT 0 COMMENT '1无效 0有效',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 10 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_unicode_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of department
-- ----------------------------
INSERT INTO `department` VALUES (1, '我的公司', NULL, '2022-04-23 22:38:49', '2022-04-23 23:03:55', 0);
INSERT INTO `department` VALUES (2, '技术部', 1, '2022-04-23 23:04:00', '2022-04-23 23:04:03', 0);
INSERT INTO `department` VALUES (3, '财务部', 1, '2022-04-23 23:17:19', '2022-04-23 23:17:22', 0);
INSERT INTO `department` VALUES (4, '大数据部', 2, '2022-04-23 23:30:26', '2022-04-23 23:30:28', 0);
INSERT INTO `department` VALUES (5, '商品部', 2, '2022-04-23 23:30:50', '2022-04-23 23:30:51', 0);
INSERT INTO `department` VALUES (6, '工程部', 1, '2022-04-23 23:31:12', '2022-04-23 23:31:14', 0);
INSERT INTO `department` VALUES (7, '测试部', 2, '2022-04-23 23:31:34', '2022-04-23 23:31:36', 0);
INSERT INTO `department` VALUES (8, '大数据研发一部', 4, '2022-04-23 23:55:05', '2022-04-24 22:34:17', 0);
INSERT INTO `department` VALUES (9, '大数据开发一部', 4, '2022-04-24 22:34:25', '2022-04-24 22:34:27', 0);
INSERT INTO `department` VALUES (10, '测试一部', 7, '2022-04-24 22:48:24', '2022-04-24 23:10:59', 0);

SET FOREIGN_KEY_CHECKS = 1;

在这里插入图片描述

三、代码实现：

//部门实体
public class Department {
    
    
    private Long id;
    private String name;
    private Long parentId;
    private Date createTime;
    private Date updateTime;
    private Integer deleteFlag;
    private List<Department> childList;
    private List<UserInfo> users;
}
//用户实体
public class UserInfo {
    
    
    private Long id;
    private String name;
    private Long departmentId;
}

public class DFSTestMain {
    
    
    public static void main(String[] args) throws SQLException {
    
    
        List<Department> departmentList = getDepartmentList();
        List<UserInfo> userList = getUserList();

        Department depTree = buildDepartment(departmentList);
        Map<Long, List<UserInfo>> userInfoMap = userList.stream().collect(Collectors.groupingBy(UserInfo::getDepartmentId));

        dfsLoadUsers(depTree , userInfoMap);
        System.out.println(JSON.toJSONString(depTree));
    }
	//获取用户列表
    private static List<UserInfo> getUserList() throws SQLException {
    
    
        List<UserInfo> userInfoList = new ArrayList<>();
        String userSql = "SELECT * FROM user_info WHERE delete_flag = 0";
        Connection con = JdbcUtil.getCon();
        Statement userStat = con.createStatement();
        ResultSet userRs = userStat.executeQuery(userSql);

        while (userRs.next()) {
    
    
            UserInfo userInfo = new UserInfo();
            userInfo.setId(userRs.getLong(1));
            userInfo.setName(userRs.getString(2));
            userInfo.setDepartmentId(userRs.getLong(3));
            userInfoList.add(userInfo);
        }
        return userInfoList;
    }
	//获取部门列表
    private static List<Department> getDepartmentList() throws SQLException {
    
    
        List<Department> departmentList = new ArrayList<>();
        String depSql = "SELECT * FROM department WHERE delete_flag = 0";
        Connection con = JdbcUtil.getCon();
        Statement depStat = con.createStatement();
        ResultSet depRs = depStat.executeQuery(depSql);

        while (depRs.next()) {
    
    
            Department department = new Department();
            department.setId(depRs.getLong(1));
            department.setName(depRs.getString(2));
            department.setParentId(depRs.getLong(3));
            department.setCreateTime(depRs.getDate(4));
            department.setUpdateTime(depRs.getDate(5));
            department.setDeleteFlag(depRs.getInt(6));
            departmentList.add(department);
        }
        return departmentList;
    }

    /**
     * TODO 建立部门树
     *
     * @param departmentList
     * @return
     */
    private static Department buildDepartment(List<Department> departmentList) {
    
    
        Map<Long, Department> depMapById = departmentList.stream().collect(Collectors.toMap(Department::getId, dep -> dep));
        Department topDep = null;
        for (Department dep : departmentList) {
    
    
            Long parentId = dep.getParentId();
            //TODO 无父节点为顶节点
            if (null == parentId) {
    
    
                topDep = dep;
                continue;
            }
            //TODO 无父节点为顶节点
            Department parentDep = depMapById.get(parentId);
            if (null == parentDep) {
    
    
                topDep = dep;
                continue;
            }
            List<Department> parentDepChildList = parentDep.getChildList();
            if (CollectionUtils.isEmpty(parentDepChildList)) {
    
    
                parentDep.setChildList(Lists.newArrayList(dep));
            } else {
    
    
                parentDepChildList.add(dep);
            }
        }
        return topDep;
    }

	//深度优先遍历将员工挂载到每个部门节点
    private static void dfsLoadUsers(Department tree, Map<Long, List<UserInfo>> deptIdUsersMap) {
    
    
        if (tree == null) {
    
    
            return;
        }

        List<Department> childList = tree.getChildList();
        if (CollectionUtils.isEmpty(childList)) {
    
    
            tree.setUsers(new ArrayList<>());
            return;
        }
        List<UserInfo> userInfos = deptIdUsersMap.get(tree.getId());
        if (!CollectionUtils.isEmpty(userInfos)) {
    
    
            tree.setUsers(userInfos);
        } else {
    
    
            tree.setUsers(new ArrayList<>());
        }
        for (Department next : childList) {
    
    
            dfsLoadUsers(next, deptIdUsersMap);
        }
    }
}

四、运行结果

{
    
    
    "childList":[
        {
    
    
            "childList":[
                {
    
    
                    "childList":[
                        {
    
    
                            "createTime":"2022-04-23",
                            "deleteFlag":0,
                            "id":8,
                            "name":"大数据研发一部",
                            "parentId":4,
                            "updateTime":"2022-04-24",
                            "users":[

                            ]
                        },
                        {
    
    
                            "createTime":"2022-04-24",
                            "deleteFlag":0,
                            "id":9,
                            "name":"大数据开发一部",
                            "parentId":4,
                            "updateTime":"2022-04-24",
                            "users":[

                            ]
                        }
                    ],
                    "createTime":"2022-04-23",
                    "deleteFlag":0,
                    "id":4,
                    "name":"大数据部",
                    "parentId":2,
                    "updateTime":"2022-04-23",
                    "users":[
                        {
    
    
                            "departmentId":4,
                            "id":0,
                            "name":"Jerry"
                        },
                        {
    
    
                            "departmentId":4,
                            "id":5,
                            "name":"Billie"
                        }
                    ]
                },
                {
    
    
                    "createTime":"2022-04-23",
                    "deleteFlag":0,
                    "id":5,
                    "name":"商品部",
                    "parentId":2,
                    "updateTime":"2022-04-23",
                    "users":[

                    ]
                },
                {
    
    
                    "childList":[
                        {
    
    
                            "createTime":"2022-04-24",
                            "deleteFlag":0,
                            "id":10,
                            "name":"测试一部",
                            "parentId":7,
                            "updateTime":"2022-04-24",
                            "users":[

                            ]
                        }
                    ],
                    "createTime":"2022-04-23",
                    "deleteFlag":0,
                    "id":7,
                    "name":"测试部",
                    "parentId":2,
                    "updateTime":"2022-04-23",
                    "users":[

                    ]
                }
            ],
            "createTime":"2022-04-23",
            "deleteFlag":0,
            "id":2,
            "name":"技术部",
            "parentId":1,
            "updateTime":"2022-04-23",
            "users":[
                {
    
    
                    "departmentId":2,
                    "id":3,
                    "name":"Tom"
                }
            ]
        },
        {
    
    
            "createTime":"2022-04-23",
            "deleteFlag":0,
            "id":3,
            "name":"财务部",
            "parentId":1,
            "updateTime":"2022-04-23",
            "users":[

            ]
        },
        {
    
    
            "createTime":"2022-04-23",
            "deleteFlag":0,
            "id":6,
            "name":"工程部",
            "parentId":1,
            "updateTime":"2022-04-23",
            "users":[

            ]
        }
    ],
    "createTime":"2022-04-23",
    "deleteFlag":0,
    "id":1,
    "name":"我的公司",
    "parentId":0,
    "updateTime":"2022-04-23",
    "users":[
        {
    
    
            "departmentId":1,
            "id":1,
            "name":"Jone"
        },
        {
    
    
            "departmentId":1,
            "id":2,
            "name":"Jack"
        }
    ]
}

广度优先遍历（BFS）

定义：

广度优先遍历全称叫Breath First Search（简称BFS），例如查询一棵树从相邻节点进行探索，附近节点探索完毕之后会深入其他层进行查找，由近到远，需要记录之前走过的上一节点方便返回（回溯），继续探索其他节点直到结束，如图所示：
最终遍历顺序：A->B->C->D->E->F-G
在这里插入图片描述

项目应用

一、项目需求

继续沿用上面项目的组织架构，这里采用广度优先遍历渲染整颗部门树。

二、代码实现

public class BFSTestMain {
    
    
    public static void main(String[] args) throws SQLException {
    
    
        List<Department> departmentList = getDepartmentList();
        List<UserInfo> userList = getUserList();

        Map<Long, List<Department>> departmentMap = departmentList.stream().collect(Collectors.groupingBy(Department::getParentId));
        Map<Long, List<UserInfo>> userInfoMap = userList.stream().collect(Collectors.groupingBy(UserInfo::getDepartmentId));
        LinkedList<Department> queue = new LinkedList<>();

        //根节点
        Department root = departmentMap.get(0L).get(0);
        queue.add(root);

        while (!queue.isEmpty()){
    
    
            Department node = queue.remove();
            Long id = node.getId();
            //获取子节点
            List<Department> childrenList = departmentMap.get(id);
            node.setChildList(childrenList);

            if (!CollectionUtils.isEmpty(childrenList)){
    
    
                queue.addAll(childrenList);
            }
        }

        dfsLoadUsers(root , userInfoMap);
        System.out.println(JSON.toJSONString(root));
    }

    private static List<UserInfo> getUserList() throws SQLException {
    
    
        List<UserInfo> userInfoList = new ArrayList<>();
        String userSql = "SELECT * FROM user_info WHERE delete_flag = 0";
        Connection con = JdbcUtil.getCon();
        Statement userStat = con.createStatement();
        ResultSet userRs = userStat.executeQuery(userSql);

        while (userRs.next()) {
    
    
            UserInfo userInfo = new UserInfo();
            userInfo.setId(userRs.getLong(1));
            userInfo.setName(userRs.getString(2));
            userInfo.setDepartmentId(userRs.getLong(3));
            userInfoList.add(userInfo);
        }
        return userInfoList;
    }

    private static List<Department> getDepartmentList() throws SQLException {
    
    
        List<Department> departmentList = new ArrayList<>();
        String depSql = "SELECT * FROM department WHERE delete_flag = 0 ";
        Connection con = JdbcUtil.getCon();
        Statement depStat = con.createStatement();
        ResultSet depRs = depStat.executeQuery(depSql);

        while (depRs.next()) {
    
    
            Department department = new Department();
            department.setId(depRs.getLong(1));
            department.setName(depRs.getString(2));
            department.setParentId(depRs.getLong(3));
            department.setCreateTime(depRs.getDate(4));
            department.setUpdateTime(depRs.getDate(5));
            department.setDeleteFlag(depRs.getInt(6));
            departmentList.add(department);
        }
        return departmentList;
    }

    private static void dfsLoadUsers(Department tree, Map<Long, List<UserInfo>> deptIdUsersMap) {
    
    
        if (tree == null) {
    
    
            return;
        }

        List<Department> childList = tree.getChildList();
        if (CollectionUtils.isEmpty(childList)) {
    
    
            tree.setUsers(new ArrayList<>());
            return;
        }
        List<UserInfo> userInfos = deptIdUsersMap.get(tree.getId());
        if (!CollectionUtils.isEmpty(userInfos)) {
    
    
            tree.setUsers(userInfos);
        } else {
    
    
            tree.setUsers(new ArrayList<>());
        }
        for (Department next : childList) {
    
    
            dfsLoadUsers(next, deptIdUsersMap);
        }
    }
}

运行结果

{
    
    
    "childList":[
        {
    
    
            "childList":[
                {
    
    
                    "childList":[
                        {
    
    
                            "createTime":"2022-04-23",
                            "deleteFlag":0,
                            "id":8,
                            "name":"大数据研发一部",
                            "parentId":4,
                            "updateTime":"2022-04-24",
                            "users":[

                            ]
                        },
                        {
    
    
                            "createTime":"2022-04-24",
                            "deleteFlag":0,
                            "id":9,
                            "name":"大数据开发一部",
                            "parentId":4,
                            "updateTime":"2022-04-24",
                            "users":[

                            ]
                        }
                    ],
                    "createTime":"2022-04-23",
                    "deleteFlag":0,
                    "id":4,
                    "name":"大数据部",
                    "parentId":2,
                    "updateTime":"2022-04-23",
                    "users":[
                        {
    
    
                            "departmentId":4,
                            "id":0,
                            "name":"Jerry"
                        },
                        {
    
    
                            "departmentId":4,
                            "id":5,
                            "name":"Billie"
                        }
                    ]
                },
                {
    
    
                    "createTime":"2022-04-23",
                    "deleteFlag":0,
                    "id":5,
                    "name":"商品部",
                    "parentId":2,
                    "updateTime":"2022-04-23",
                    "users":[

                    ]
                },
                {
    
    
                    "childList":[
                        {
    
    
                            "createTime":"2022-04-24",
                            "deleteFlag":0,
                            "id":10,
                            "name":"测试一部",
                            "parentId":7,
                            "updateTime":"2022-04-24",
                            "users":[

                            ]
                        }
                    ],
                    "createTime":"2022-04-23",
                    "deleteFlag":0,
                    "id":7,
                    "name":"测试部",
                    "parentId":2,
                    "updateTime":"2022-04-23",
                    "users":[

                    ]
                }
            ],
            "createTime":"2022-04-23",
            "deleteFlag":0,
            "id":2,
            "name":"技术部",
            "parentId":1,
            "updateTime":"2022-04-23",
            "users":[
                {
    
    
                    "departmentId":2,
                    "id":3,
                    "name":"Tom"
                }
            ]
        },
        {
    
    
            "createTime":"2022-04-23",
            "deleteFlag":0,
            "id":3,
            "name":"财务部",
            "parentId":1,
            "updateTime":"2022-04-23",
            "users":[

            ]
        },
        {
    
    
            "createTime":"2022-04-23",
            "deleteFlag":0,
            "id":6,
            "name":"工程部",
            "parentId":1,
            "updateTime":"2022-04-23",
            "users":[

            ]
        }
    ],
    "createTime":"2022-04-23",
    "deleteFlag":0,
    "id":1,
    "name":"我的公司",
    "parentId":0,
    "updateTime":"2022-04-23",
    "users":[
        {
    
    
            "departmentId":1,
            "id":1,
            "name":"Jone"
        },
        {
    
    
            "departmentId":1,
            "id":2,
            "name":"Jack"
        }
    ]
}

猜你喜欢

转载自blog.csdn.net/weixin_42380504/article/details/124543290
今日推荐
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
开源日报 | 工业开源项目OGG 1.0；姐姐，你要和我一起配置火狐吗；苹果AI遥遥落后？Fedora 40
开放签电子签章：停止新增，优化体验，前进更进（五一假期前工作）
开源日报 | 中学生开源前端动画引擎；全球首个Llama3 8B中文版开源模型；联想电脑恐出局；Linus讽刺AI炒作
“百模大战”必有一战 | 2024中国“百模大战”竞争格局分析
周排行
Family Tree 题解
BZOJ 1093 最大半连通子图 SCC + DP
幂等处理
Spring----学习（2）----XML 配置Bean 自动装配
SQL Server 远程更新目标表数据
HIbernate3.6 环境搭建
特殊符号正则表达式
【Linux】第一章 进程的理解
843. n-皇后问题（dfs+输出各种情况）
空间数据库2
每日归档
更多
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)
2024-04-17(5)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022