部门树的高效解决方案

已于 2024-01-09 00:11:43 修改
阅读量410 收藏 7
点赞数 7
文章标签： java 算法 哈希表 数据库
于 2024-01-08 20:19:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43301229/article/details/135465512
版权

数据结构与表结构

树表是一种数据结构，用于展示具有层级关系的数据。

在数据库中通常以邻接表法存储（存储父节点）。

数据库数据

问题

        前端往往是需要一个树形结构。

        后端应该如何生成这样一棵树呢？

        如何保证修改操作不会出现环呢？

        删除操作如何判断是否存在子节点？

        最后如何保证操作的效率？

实体类

        由于使用了hashSet和hashMap，所以部门实体类和树都需要重写equals和hashCode方法。

数据库对应的Dept

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Dept implements Cloneable {
    String id; // 部门ID
    String name; // 部门名称
    String pid; // 父部门ID
    @Override
    public Dept clone() {
        try {
            return (Dept) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException(e);
        }
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Dept dept = (Dept) o;
        return Objects.equals(id, dept.id);
    }
    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}

返回给前端的Tree

@Data
@AllArgsConstructor
@NoArgsConstructor
/**
 * 树节点类
 * @param <T> 节点值的类型
 */
public class Tree<T> {
    T val; // 节点
    Set<Tree<T>> children=new LinkedHashSet<>(); // 子节点集合

    /**
     * 构造方法，创建一个树节点
     * @param val 节点值
     */
    public Tree(T val) {
        this.val = val;
    }

    /**
     * 移除指定的子节点
     * @param tree 要移除的子节点
     * @return 是否移除成功
     */
    public boolean remove(Tree<T> tree){
        return children.remove(tree);
    }

    /**
     * 添加指定的子节点
     * @param tree 要添加的子节点
     * @return 是否添加成功
     */
    public boolean add(Tree<T> tree){
        return children.add(tree);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Tree<?> tree = (Tree<?>) o;
        return Objects.equals(val, tree.val);
    }

    @Override
    public int hashCode() {
        return Objects.hash(val);
    }
}

操作

        因为获取部门是一个极其频繁的操作，所以我对它进行了一个缓存（下面的treeMap），并对它进行维护。这样可以使得每次查询部门树都是O(1)的时间复杂度。

构建树并存入缓存

先将所有节点放入Map中，在将所有节点添加自己的父节点中。时间复杂度O(N)

    DeptDao deptDao = new DeptDao();  // DeptDao对象,这里是模拟dao
    Map<String, Tree<Dept>> treeMap=new HashMap<>();  // 缓存部门树
    /**
     * 构建部门树形结构，时间复杂度O(N),空间复杂度O(N)
     * 先将所有节点放入Map中，在将所有节点添加自己的父节点中。时间复杂度O(N)
     */
    private void builder() {
        List<Dept> list = deptDao.list();  // 获取部门列表
        treeMap.put("0", new Tree<>(new Dept("0", null, "-1")));    // 根节点。如果不想返回根节点，可以在查询时返回根节点的子节点
        //1.放入map集合中
        list.forEach(dept -> treeMap.put(dept.getId(), new Tree<Dept>(dept)));  // 将部门对象添加到TreeMap中

        // 将部门对象添加到父节点中
        list.forEach(o -> {
            Tree<Dept> tree = treeMap.get(o.getPid());
            if (tree == null) return;
            tree.getChildren().add(treeMap.get(o.getId()));
        });
    }

查询某个部门下的部门树

由于我们构建树时将树缓存起来了，并且我们获取的就是一颗完整的树。时间复杂度O(1)

	/**
     * 获取指定id的部门树形结构
     * @param id 部门id
     * @return 部门树形结构
     */
    public Tree<Dept> getTree(String id) {
        return treeMap.get(id);
    }

查询某部门下的直接子部门

我们缓存的是树结构，不能直接返回，需要做一个映射。时间复杂度O(m)（m为直接子节点的个数）

    /**
     * 根据指定的id返回部门树的子部门列表
     *
     * @param id 部门id
     * @return 子部门列表
     */
    public List<Dept> list(String id) {
        // 获取指定id对应的部门树
        Tree<Dept> deptTree = treeMap.get(id);
        // 获取部门树的子部门列表。
        List<Dept> children = deptTree.getChildren().stream().map(tree -> tree.getVal()).collect(Collectors.toList());
        // 返回子部门列表
        return children;
    }

增加部门

增加部门并维护其父节点。因为containsKey是LinkedHashSet中的方法，所以复杂度为O(1)

    /**
     * 添加部门
     * @param dept 部门对象。请在控制层做不为null校验
     * @return 添加成功返回true，否则返回false
     */
    public boolean add(Dept dept) {
        // 判断是否已存在
        if (treeMap.containsKey(dept.getId())) {
            throw new RuntimeException("部门已存在");
        }
        // 判断上级部门是否存在。注：如要添加一级部门，请将pid设为0。
        if (!treeMap.containsKey(dept.getPid())) {
            throw new RuntimeException("父部门不存在");
        }
        // 添加部门
        if (deptDao.add(dept)) {
            // 添加到父节点中
            treeMap.get(dept.getPid()).add(new Tree<Dept>(dept));
            return true;
        }
        return false;
    }

删除部门

在删除部门之前，需要先判断一下该部门下是否有子部门。再进行删除。复杂度O(1)

判断是否存在子部门
    /**
     * 判断指定id的部门是否存在子部门
     * @param id 部门id
     * @return 是否存在子部门
     */
    public boolean hasChild(String id) {
        return treeMap.get(id).getChildren().size() > 0;
    }
删除
    /**
     * 删除指定id的部门
     * @param id 部门id
     * @return 是否成功删除部门
     */
    public void delete(String id) {
        if (hasChild(id)) {
            throw new RuntimeException("该部门存在子部门，不能删除");
        }
        if (deptDao.remove(id)) {
            treeMap.remove(id);
        }
    }

修改

修改名字没什么好讲，主要是修改上级部门。

修改上级分两步：

  1. 判断新的父部门是否是自己，或者自己的子部门。（防止产生环）
  2. 修改数据库以及维护缓存。这里修改缓存需要先从原先自父节点中移除自己。再将自己添加到新的父节点中。

其中第一步复杂度O(k)（新父节点到更节点的长度），第二步时间复杂度O(1)。

判断是否为环
    /**
     * 判断是否存在循环部门
     *
     * @param dept 要更新的部门对象
     * @return 是否存在循环部门
     */
    private boolean isLoop(Dept dept) {
        // 当前部门id
        String id = dept.getId();
        Tree<Dept> parent = treeMap.get(dept.getPid()); //获取父节点
        while (parent != null) {
            Dept p = parent.getVal();
            // 如果当前部门id和父级id相等，则存在循环部门，返回true
            if (id.equals(p.getId())) {
                return true;
            }
            //向上级遍历
            parent = treeMap.get(p.getPid());
        }
        // 不存在循环部门，返回false
        return false;
    }
更新部门信息
    /**
     * 更新部门信息
     *
     * @param newDept 待更新的部门对象。Dept在控制层需要做数据校验，如id不为空，pid不为空。id!=0。
     */
    public void update(Dept newDept) {
        // 判断是否为循环部门
        if (isLoop(newDept)) {
            throw new RuntimeException("不能设置父部门为自己或子部门");
        }

        // 获取要更新的部门节点
        Tree<Dept> treeNode = treeMap.get(newDept.getId());
        // 获取原部门节点
        Dept oldNode = treeNode.getVal();

        // 更新部门信息
        if (deptDao.update(newDept)) {
            // 从原父节点中删除部门节点
            treeMap.get(oldNode.getPid()).remove(treeNode);
            // 添加到新父节点中
            treeMap.get(newDept.getPid()).add(treeNode);
        }
    }

完整的增删改查代码

public class DeptService {
    DeptDao deptDao = new DeptDao();  // DeptDao对象,这里是模拟dao
    Map<String, Tree<Dept>> treeMap = new HashMap<>();  // 存储部门树

    public DeptService() {
        builder();  // 构建部门树
    }

    /**
     * 构建部门树形结构，时间复杂度O(N),空间复杂度O(N)
     * 先将所有节点放入Map中，在将所有节点添加自己的父节点中。时间复杂度O(N)
     */
    private void builder() {
        List<Dept> list = deptDao.list();  // 获取部门列表
        treeMap.put("0", new Tree<>(new Dept("0", null, "-1")));    // 根节点。如果不想返回根节点，可以在查询时返回根节点的子节点
        //1.放入map集合中
        list.forEach(dept -> treeMap.put(dept.getId(), new Tree<Dept>(dept)));  // 将部门对象添加到TreeMap中

        // 将部门对象添加到父节点中
        list.forEach(o -> {
            Tree<Dept> tree = treeMap.get(o.getPid());
            if (tree == null) return;
            tree.getChildren().add(treeMap.get(o.getId()));
        });
    }

    /**
     * 获取指定id的部门树形结构
     *
     * @param id 部门id
     * @return 部门树形结构
     */
    public Tree<Dept> getTree(String id) {
        return treeMap.get(id);
    }

    /**
     * 根据指定的id返回部门树的子部门列表
     *
     * @param id 部门id
     * @return 子部门列表
     */
    public List<Dept> list(String id) {
        // 获取指定id对应的部门树
        Tree<Dept> deptTree = treeMap.get(id);
        // 获取部门树的子部门列表。
        List<Dept> children = deptTree.getChildren().stream().map(tree -> tree.getVal()).collect(Collectors.toList());
        // 返回子部门列表
        return children;
    }

    /**
     * 添加部门
     *
     * @param dept 部门对象。请在控制层做不为null校验
     * @return 添加成功返回true，否则返回false
     */
    public boolean add(Dept dept) {
        // 判断是否已存在
        if (treeMap.containsKey(dept.getId())) {
            throw new RuntimeException("部门已存在");
        }
        // 判断上级部门是否存在。注：如要添加一级部门，请将pid设为0。
        if (!treeMap.containsKey(dept.getPid())) {
            throw new RuntimeException("父部门不存在");
        }
        // 添加部门
        if (deptDao.add(dept)) {
            // 添加到父节点中
            treeMap.get(dept.getPid()).add(new Tree<Dept>(dept));
            return true;
        }
        return false;
    }


    /**
     * 更新部门信息
     *
     * @param newDept 待更新的部门对象。Dept在控制层需要做数据校验，如id不为空，pid不为空。id!=0。
     */
    public void update(Dept newDept) {
        // 判断是否为循环部门
        if (isLoop(newDept)) {
            throw new RuntimeException("不能设置父部门为自己或子部门");
        }

        // 获取要更新的部门节点
        Tree<Dept> treeNode = treeMap.get(newDept.getId());
        // 获取原部门节点
        Dept oldNode = treeNode.getVal();

        // 更新部门信息
        if (deptDao.update(newDept)) {
            // 从原父节点中删除部门节点
            treeMap.get(oldNode.getPid()).remove(treeNode);
            // 添加到新父节点中
            treeMap.get(newDept.getPid()).add(treeNode);
        }
    }

    /**
     * 判断是否存在循环部门
     *
     * @param dept 要更新的部门对象
     * @return 是否存在循环部门
     */
    private boolean isLoop(Dept dept) {
        // 当前部门id
        String id = dept.getId();
        Tree<Dept> parent = treeMap.get(dept.getPid()); //获取父节点
        while (parent != null) {
            Dept p = parent.getVal();
            // 如果当前部门id和父级id相等，则存在循环部门，返回true
            if (id.equals(p.getId())) {
                return true;
            }
            //向上级遍历
            parent = treeMap.get(p.getPid());
        }
        // 不存在循环部门，返回false
        return false;
    }

    /**
     * 判断指定id的部门是否存在子部门
     *
     * @param id 部门id
     * @return 是否存在子部门
     */
    public boolean hasChild(String id) {
        return !treeMap.get(id).getChildren().isEmpty();
    }

    /**
     * 删除指定id的部门
     *
     * @param id 部门id:需要在控制层做数据校验，例如不为空，id!=0
     * @return 是否成功删除部门
     */
    public void delete(String id) {
        if (hasChild(id)) {
            throw new RuntimeException("该部门存在子部门，不能删除");
        }
        if (deptDao.remove(id)) {
            treeMap.remove(id);
        }
    }
}

最坏情况时间复杂度

该方案

  • 新增：O(1)
  • 查询树：O(1)
  • 修改：O(n)
  • 删除：O(1)
  • 查询直接子部门：O(n)

空间复杂度均为O(n)

不死的小白
关注
  • 7
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
部门树
sdzhangshulong的博客
08-29 984
service public List&lt;DeptLevelDto&gt; deptTree() { List&lt;SysDept&gt; deptList = sysDeptMapper.getAllDept(); List&lt;DeptLevelDto&gt; dtoList = Lists.newArrayList(); ...
部门树的实现
baweizhinengfei的博客
05-22 3414
       在很多案例中都用到树Tree，这里以部门树为例，来讲述整个的实现思路。树给人的感觉是有层级划分的，而且是有排序的，首先我们去构建部门树的数据库表结构，下面是表的sql语句；CREATE TABLE `sys_dept` (  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '部门id',  `name` varchar(20) NOT NUL...
java简单开发部门树（Tree）
09-27
部门组织显示开发，从jsp到后台java都有详细解析，同时提供有相关的js。开发内容简单，适合初学者和忘记部门树开发者。
如何构建机构，部门树
qq2211324766的博客
08-14 894
职场萌新最近又碰到头疼的需求，需要把机构数据构造成树型结构传给前端。当时想的是第一次把所有顶级机构传给前端，前端每次展开机构的时候，把当前机构id传给我，我直接找出它的下级机构给前端。因为有了解过一些前端的知识，觉得每次发异步请求，页面理论应该是能够实现的。可是前端小姐姐能力有限，说今天要是不给树结构就找其他小哥哥去联调了，那咱肯定不同意是吧，只能亲自操刀构建树型结构数据。这里考虑到有的兄弟可能在工作没时间具体看，先上干货吧。...
部门机构树
yuanliang4521的专栏
10-03 737
组织机构是典型的层次树结构表，以下就以组织为例开始分析 1. 部门机构树如下 ┌─────────────── │ │ 部门 │ │ ...
h5移动端部门树展示
04-13
下面我们将深入探讨如何实现一个高效的H5移动端部门树展示。 1. **HTML5技术基础**： H5（HTML5）是HTML的最新版本，它引入了许多新的API和元素，提高了网页的交互性和可用性。在移动端，H5能够提供跨平台的解决...
弱电系统工程解决方案 弱电系统工程解决方案
04-25
综上，弱电系统工程解决方案是一个全面而细致的过程，从规划到实施再到后期运维，每一个环节都需要专业且周密的考虑，以实现系统的高效、稳定运行。通过这样的解决方案，可以构建出一个安全、智能、便捷的现代化生活...
综合智能IT运维管理解决方案.pptx
10-13
这个解决方案旨在将传统的IT运维管理模式与先进的智能化技术相结合，以提供更高效、更贴合业务的服务。 首先，我们要理解IT管理技术的发展历程。从ITIL（信息技术基础设施库）、ITSM（IT服务管理）到ISO20000、...
无人机林业有害生物监测解决方案
06-06
在当前的智慧林业领域，无人机林业有害生物监测解决方案已经成为一种高效、精确的现代技术手段。这一解决方案通过结合无人机的高机动性和遥感技术，能够实时、动态地监测森林中的病虫害情况，为林业管理者提供及时、...
java部门树形开发
09-19
从jsp（js、css）-》dao层-》service层-》controller层一步步实现过程，word已经加载了部分js和css，不需要再在网上下载，但是ajax的js需要自己下载
包含部门树与权限模块树的权限管理
09-02
详细的权限管理项目,代码类mybatis生成,校验参数BeanValidator,部门树以及权限模块树的代码需要好好分析
智能交通高清卡口安防解决方案.pdf
09-30
总的来说，智能交通高清卡口安防解决方案通过科学的勘测、精细的布局、严谨的安装和调试，构建起一套高效、可靠的交通监控网络，为现代交通管理和公共安全提供强大的技术支持。这种解决方案不仅提高了交通违法行为的...
部门树问题
最新发布
r8t7y6的博客
12-03 73
此时，如果判断某节点A是否可移动到节点B，只需要判断节点B的层数（可以通过路径得知）+ 节点A最深子节点的深度（可以通过数据库查询与节点A路径匹配的子节点，并循环得到最大深度）。这个方案问题在于，移动以后，节点A原本的所有父节点，他的层级关系改变了，也就是所有他的父节点最深深度变了，那么就不得不维护从根节点开始，整个树的所有节点的子节点最大深度。也就是说，其实并未解决此题，但是把限制一的深度限制去掉，即可简单实现该需求，是否又更好的方法，期待留言。某节点10, 则存储路径为 1，2，5，6，10。
部门树/菜单树（递归）
weixin_46237429的博客
01-20 706
部门树/菜单树实体类递归方法测试结果学习先找一级在递归找注意 实体类 import java.util.Date; import java.util.List; /** * @ClassName FoodClassTree * @description: 实体类 * @author: 一粒麦子 * @Date 2021/1/20 16:29 **/ public class FoodClassTree { private static final long serialVersionU
用递归构建组织树
fenyu8的专栏
10-22 1037
/** * output package name */ package com.kingdee.eas.testunit.client; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import org.apache.log4j.Log
java部门树_使用递归算法简单实现一个部门树
weixin_39856208的博客
02-15 897
组织树可能是在我们实际开发中经常会使用到的一个方法了，如何简单快速的将一个list组装成一个tree呢，我简单写了一个示例，当然性能可能不是最优的，还有待调整和提升，也欢迎小伙伴们提出自己的想法定义了一个DepartmentPO类，用来组装这个tree的对象public class DepartmentPO implements Serializable,Comparable{private st...
Java后端项目实现无限极树 - 案例：部门树 - Department实体类
2301_77829365的博客
07-19 612
注意：在业务实现时，其实只用到了 departmentMapper 中的一个 findAll() 方法，即查询所有对象数据，所以在 mapper 层以及 sql 语句中不会有所新增（基础的 CRUD 方法一般而言早就写好了），至此，部门数的后端业务就已经全部实现了，剩下的就是前端的事了。if (department.getParentId() == null) {//顶级部门的情况。// 3. 遍历所有部门只要不是第一层级的，找自己的上级，并将自己放入上级的children中。
若依框架-部门树状图
xwwwwww903的博客
07-21 3057
若依框架部门树状的实现流程
SSHI架构开发平台：高效稳定的J2EE解决方案
"基于SSHI架构的开发平台技术方案，是一种综合运用Spring、Struts、Hibernate和Ibatis的J2EE平台解决方案。该方案旨在提供一个技术先进、安全、稳定且高效的开发环境，适用于中小型软件公司和企业IT部门的研发团队。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值