JAVA后端生成树算法，从指定的叶子节点到树根生成树，从树根到所有叶子结点

最新推荐文章于 2024-05-20 11:26:33 发布
最新推荐文章于 2024-05-20 11:26:33 发布
阅读量5.6k 收藏 13
点赞数 2
文章标签： 生成树 叶子节点 树叶层建树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010241027/article/details/89189657
版权

4/11 10:20 更新了一些算法解释

4/18 17:17 更新了生成子树的方法，更加灵活了

先贴代码吧


import java.util.*;

/**
 * @Author xjd
 * @Date 2019/4/3 10:30
 * @Version 1.0
 */
public class GeTreeUtil {

    /**
     * 传入的节点结构必须继承本工具支持的数据结构
     * @author xjd
     * @date 2019/4/10 17:20
     */
    public static class BaseTreeNode{
        protected Long id;
        protected Long pid;
        protected Boolean leafNode;
        protected List<BaseTreeNode> childList;

        protected BaseTreeNode(Long id, Long pid, Boolean leafNode, List<BaseTreeNode> childList) {
            this.id = id;
            this.pid = pid;
            this.leafNode = leafNode;
            this.childList = childList;
        }
    }

    /**
     * 根据叶子节点生成只包含叶子节点分支的树，可以是深林，最终汇成一棵树
     * @param allNodeList 整棵树或者整个深林的所有的节点
     * @param leafNodeList 需要展示的叶子节点
     * @return 分支树
     */
    public static List<? extends BaseTreeNode> getBranchTree(List<? extends BaseTreeNode> allNodeList, List<? extends BaseTreeNode> leafNodeList){
        Hashtable<Long, List<BaseTreeNode>> dicNode = new Hashtable<>();
        for (BaseTreeNode baseTreeNode : leafNodeList) {
            List<BaseTreeNode> childList = dicNode.get(baseTreeNode.pid);
            if(null == childList){
                childList = new ArrayList<>();
                dicNode.put(baseTreeNode.pid, childList);
            }
            childList.add(baseTreeNode);
        }
/*        Map<Long, BaseTreeNode> allNodeMap = new HashMap<>();
        for (BaseTreeNode node : allNodeList) {
            allNodeMap.put(node.id, node);
        }*/

        if(dicNode.isEmpty()){
            return Collections.emptyList();
        }
        while (!(dicNode.containsKey(-1L) && dicNode.size() == 1)){ // 递归出口
            ConbineDirectParant(allNodeList, dicNode);
//            dicNode = ConbineDirectParant(allNodeMap, dicNode); // 这种实现慢一些
        }
        return dicNode.get(-1L);
    }

    /**
     * 自底向上，每次每个叶子节点上升一层，查找并合并一层的父子关系，通过dicNode里面的父子关系把children并到父节点数据结构的childList中
     * @param allNodeList 所有节点，已经找到祖宗孩子关系的节点就remove，不重复添加
     * @param dicNode 每次只存一层关系合并完就删除，最后只剩下根节点和第一层节点的父子关系
     */
    public static void ConbineDirectParant(List<? extends BaseTreeNode> allNodeList, Hashtable<Long, List<BaseTreeNode>> dicNode){
        Iterator<BaseTreeNode> iterator = (Iterator<BaseTreeNode>) allNodeList.iterator();
        while (iterator.hasNext()){
            BaseTreeNode parentNode = iterator.next();
            if(dicNode.containsKey(parentNode.id)){ // 爸爸
                List<BaseTreeNode> childList = dicNode.get(parentNode.id);
                // 把父子关系保存在node结构体，dicNode的父子关系就可以remove了
                parentNode.childList.addAll(childList);
                AddOneNode(parentNode, dicNode);
                //  删除已经用完了的下一级，构造dicNode.size==1的递归出口，保证不同树叶子节点都可以递归到深林的根
                dicNode.remove(parentNode.id);
                iterator.remove();
            }
        }
    }

    /**
     * 更新dicNode的父子关系，把当前节点合并到上一层的父子关系或者升级到上一层的父子关系
     * @param node dicNode中的Key对应的节点，也就是value的父节点
     * @param dicNode
     */
    private static void AddOneNode(BaseTreeNode node, Hashtable<Long, List<BaseTreeNode>> dicNode) {
        List<BaseTreeNode> childList = dicNode.get(node.pid);
        if(childList != null){
            childList.add(node);
        }else {
            dicNode.put(node.pid, new ArrayList<>(Arrays.asList(node)));
        }
    }

    /**
     * 传入一棵树或者深林的需要展示的所有节点，生成深林或者树机构
     * @param valueList 需要展示的所有节点
     * @return 一棵树或一个深林
     */
    public static List<?> geFullTree(List<? extends BaseTreeNode> valueList){

        Map<Long, BaseTreeNode> nodeMap = new HashMap<>();
        List<BaseTreeNode> rootNodeList = new ArrayList<>();

        for (BaseTreeNode node : valueList) {
            Long id = node.id;
            Long pid = node.pid;
            BaseTreeNode baseTreeNode = nodeMap.get(id);
            if (baseTreeNode != null) {
                node.childList.addAll(baseTreeNode.childList);
//                nodeMap.remove(id); // 会自动覆盖相同key，不用remove
            }
            nodeMap.put(id, node);

            BaseTreeNode parentNode = nodeMap.get(pid);
            if (parentNode != null) {
                if(parentNode.childList == null){
                    parentNode.childList = new ArrayList<>();

                }
                parentNode.childList.add(node);
            }else{
                nodeMap.put(pid, new BaseTreeNode(pid, null, null, new ArrayList<>(Arrays.asList(node))));
            }

            if(new Long(-1L).equals(pid)){
                rootNodeList.add(node);
            }
        }

        return rootNodeList;
    }

    /**
     * 传入所有结点，和需要生成的子树的id
     * @param valueList
     * @param childTreeRootId
     * @return
     */
    public static BaseTreeNode GeChildTree(List<? extends BaseTreeNode> valueList, Long childTreeRootId){

        Map<Long, BaseTreeNode> nodeMap = new HashMap<>();

        for (BaseTreeNode node : valueList) {
            Long id = node.id;
            Long pid = node.pid;
            BaseTreeNode childNode = nodeMap.get(id);
            if (childNode == null) {
                childNode = node;
            }else{
                // 遍历到孩子的时候已经put，只拿childlist复制到node
                if (childNode.childList != null) {
                    if (node.childList == null) {
                        node.childList = new ArrayList<>();
                    }
                    node.childList.addAll(childNode.childList);
                }
                childNode = node;
            }
            // 每次都put为了nodeMap存的是传进来子类类型
            nodeMap.put(id, childNode);

            BaseTreeNode parentNode = nodeMap.get(pid);
            if (parentNode == null) {
                parentNode = new BaseTreeNode(pid, null, false, new ArrayList<>(Arrays.asList(childNode)));
                nodeMap.put(pid, parentNode);
            }else{
                if (parentNode.childList == null) {
                    parentNode.childList = new ArrayList<>();
                }
                parentNode.childList.add(childNode);
            }
        }
        return nodeMap.get(childTreeRootId);
    }

    /**
     * 生成分支树的另一种递归实现，直接从dicNode（一代父子关系）查找key对应的节点 而不遍历所有节点
     * @param allNodeMap
     * @param dicNode
     * @return
     */
    public static Hashtable<Long, List<TagNode>> ConbineDirectParant(Map<Long, TagNode> allNodeMap, Hashtable<Long, List<TagNode>> dicNode){
        Hashtable<Long, List<TagNode>> newdicNode = new Hashtable<>();
        for (Long aLong : dicNode.keySet()) {
            List<TagNode> childList = dicNode.get(aLong);
            TagNode parentNode = allNodeMap.get(aLong);
            if (parentNode != null){
                if(parentNode.childList == null){
                    parentNode.childList = new ArrayList<>();
                }
                for (TagNode childTagNode : childList) {
                    Integer leafNode = childTagNode.leafNode;
                    Boolean bLeafNode = new Integer(1).equals(leafNode) ? true : false;
                    BaseTreeNode baseTreeNode;
                    if(bLeafNode){
                        baseTreeNode = new TagNode(childTagNode.tagId, childTagNode.tagPid, bLeafNode, null);
                    }else{
                        baseTreeNode = new TagNode(childTagNode.tagId, childTagNode.tagPid, bLeafNode, childTagNode.childList);
                    }
                    ((TagNode) baseTreeNode).tagName = childTagNode.tagName;
                    ((TagNode) baseTreeNode).tagType = childTagNode.tagType;
                    ((TagNode) baseTreeNode).tagTypeName = childTagNode.tagTypeName;
                    parentNode.childList.add(baseTreeNode);
                }
                List<TagNode> tagNodes = dicNode.get(parentNode.tagPid);
                if (tagNodes == null) {
                    tagNodes = new ArrayList<>();
                }
                tagNodes.add(parentNode);
                newdicNode.put(parentNode.tagPid, tagNodes);

                allNodeMap.remove(aLong);
            }
        }
        return newdicNode;
    }

}

最后一个方法可以不用看，没有完善的，直接传了子类

 

只要继承我定义的BaseTreeNode结构的节点可以用这个工具

根节点为id为-1

继承BaseTreeNode需要先初始化父类的属性，子类的节点自行构造，但都必须还有父类的属性

生成整棵树的算法应该没什么亮点，把所有节点遍历一次，边存父子关系边合并到根节点。

 

难点是从叶子节点自底向上生成树

一层一层递归，好像解释都写在代码注释上了。

算法解释：

dicNode是用来存储一代的关系的key--父亲id，value--childlist

    先存一份所有叶子结点和其父节点的关系到一个HashTable里（dicNode），这个HashTable只存一代的父子关系，

每次递归 向上查一层父亲，

第一次递归能保存到叶子结点本身（存储在父节点的childList），

叶子结点的pid对应的父节点（存储在dicNode的value中，合并到已经存了伯父的list中或者创建一个暂时只有自身一个元素的list中），

父节点的pid（存储在dicNode的key中），

一共三代关系。

然后remove掉已经归并了的（已经找到组织的）key，为了最后的递归出口是所有关系都归并到一个根节点（id==-1）并且只剩下一代（最顶层的一代）关系，避免了有些叶子结点率先找到了根节点，而有些层次较低的还没找到（如果这时候跳出递归了就会只找到了层次最小的叶子结点的分支，其他的还没来得及合并就被丢弃了），所以要保证dicNode最终有且只有一个根节点关系

第二次以及后面的递归都是向上找一层，合并，最后剩下一个根节点的关系。

 

有看不懂的评论，我会看。

之前找从叶子节点生成树的方法没找到合适的，就自己尝试着研究一下。

深受张艳玲老师的开源思想的影响，就分享出来了

希望有大佬可以帮我优化一下，感觉我写得还是不够完善。

 

-----------

引用参考文章 ：

如何从树叶层开始建树？

https://blog.csdn.net/xuexiaodong009/article/details/12086769

 

徐猿
关注
  • 2
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
java 通用树_具有节点过滤的Java通用树遍历
weixin_34942785的博客
02-25 1039
回答(4)2 years ago我建议你尝试以下方法：方法 boolean removeRecursively(String id, Set leavesToKeep) 将从具有给定 id 的节点遍历到此分支离开 .首先，我们检查一下是不是一个叶子 . 如果叶子不在 leavesToKeep 集合中，我们将其删除并返回 true ，否则返回 false . 这是我们递归的基本情况 .如果节点不是...
2016-2017(B卷)1
08-03
9. 构造哈夫曼树的过程涉及最小生成树，加权路径长度WPL是所有叶子节点到根节点的路径长度之和。 10. 冒泡排序在最好情况下，即输入序列已经完全排序，其时间复杂度是O(n)。 选择题涉及的知识点包括算法特性、...
知道叶子节点集合怎么生成树
大杂烩
12-23 912
先说一下问题吧 有一颗任意节点的树型结构，级数和节点数不确定，给定叶子节点集合怎么按照原树生成一颗树。要求父节点的子节点如果都不在集合中，则该节点不显示。 我目前想到的算法这样 定义树形结构： treeNode{ id name parentid set } 定义一Map存放父节点对象。 利用递归遍历叶子节点集合，取父节点id，检查Map中是否存在该节点。 如果...
根据叶子节点生成树结构
最新发布
qq958576393的博客
05-20 263
).sorted(Comparator.comparing(排序规则).collect(Collectors.toList());}).sorted(排序规则).collect(Collectors.toList());获取满足条件的叶子节点，针对这些节点生成一颗非完整的树，减少展示非必要的树结构。1.递归查询数据库，获取满足条件叶子节点的完整树分支（需要去重）// 获取所有顶层选项，过滤出根节点。where 满足条件的叶子节点。2.查数据库获取所有满足条件的叶子节点。where 满足条件的叶子节点。
从叶子节点反向构建树 java
weixin_50185953的博客
03-17 587
新建数据源对象DataSourcce，一般为从数据库查询到的数据。新建树对象TreeNode，即需要返回的树节点对象。核心方法buildDataSourceTree。
java树结构Tree生成
土拨鼠博客
05-25 695
该方法的实现非常简单，其主要思想是将节点集合转换为节点映射表，然后遍历节点映射表，如果找到了父节点，则将该节点添加到父节点的子节点列表中。如果没有找到父节点，则说明该节点为根节点（或者是孤立的节点），将其添加到结果集中。总的来说，这篇文章对Java树结构的解析进行了详尽的介绍，给读者提供了一个很好的参考。特别是对于那些需要使用树形结构的开发者来说，这篇文章提供了一个通用的实现方法，可以最大程度地减少代码的重复率和出错率。来为不同类型的节点提供统一的抽象接口，这很好地体现了Java语言的面向对象特性。
树节点从叶子节点向上递归计算
ww_ndsc_ww的专栏
06-21 621
树节点从叶子节点向上递归计算
JAVA 树状结构数据_根到每个最底层叶子的路径
Axel_Fran的博客
08-10 348
数据结构： public class node { private String text; private List<node>childList; public String getText() { return text; } public void setText(String text) { this.text = text; } public List<node> get
哈夫曼编码实现图像压缩
04-17
b) 由于对于最后生成的 Haffman 树，其所有叶子结点均为从一个内部树扩充出去的，所以当外部叶子结点数为 m 个时，内部结点数为 m-1，整个 Haffman 树的需要的结点数为 2m-1。 c) 初始化 Haffman 树分两步进行，先...
黄淮学院《数据结构》期末考试试卷.pdf
01-12
8. 森林与二叉树的关系：森林F对应的二叉树根节点的右子树代表的是森林中除了第一棵树之外的其他树，所以度为0的结点个数是M2+M3。 9. 无向图的边数：无向图的顶点数为n时，最多可能有的边数是n*(n-1)/2，这是完全...
数据结构联考试卷4及答案1
08-03
**解答题**和**算法设计题**涉及到的具体解题步骤和算法实现就不在此详述，这些题目需要根据给定的森林、关键字序列、二叉树结构、无向图邻接表和无向网，分别进行森林转化为二叉树、快速排序过程、二叉排序树的构建...
数据结构试卷及参考答案_91
08-08
森林转换成二叉树时，第一个树的根节点没有左孩子，因此二叉树根节点的左子树结点数为N2+N3，对应答案D。 3. 插入排序是一种简单直观的排序算法，第四题中直接插入排序的时间复杂度在最坏情况下为O(n^2)，对应答案C...
数据结构与算法-知道树的某几个叶子节点，将所有包含该叶子节点的路径组成一颗新的树
Riptide
04-04 1011
上一次记录博客是过年之前，太久了。。2月比较懒散，3月忙着加班，今天终于有时间重新开始记录点零碎的东西。 前景提要，有一个特殊的需求： 现在的情况是，知道叶子节点【唯一标识】以及树， 求一颗新的树。 思路： 递归给每一个节点一个标记。 对于每一个叶子节点来说，如果已知的叶子节点包含这个叶子节点，那么给标记为true。 对于非叶子节点来说，如果子节点中有一个标记为true，那么该节点标记为tr...
基本数据结构：树（tree）
weixin_30493321的博客
08-14 120
基本数据结构：树（tree） 作者：C小加更新时间：2012-8-3 无论是链表，栈还是队列，它们都是线性结构的，每个节点的左边最多一个节点，右边也最多一个节点，对于大量的输入数据，线性表的访问时间太慢，不宜使用。这里我要说一种非线性的数据结构，其大部分操作的运行时间平均为O(logn)。 我们涉及到的这种数据结构叫做树。在计算机科学中，树是非常有用的抽象概念。我们形象的去描述一棵树，一个...
Java获取一棵树的3种方法
qq243920161的博客
10-21 1216
树在很多地方都会用到，比如权限菜单、省市县等等，思路就是先把列表查出来，然后再生成一棵树
Java数据结构—树
Green_756的博客
09-05 3892
java、数据结构、树
java搜索树形结构数据,叶子节点并一起带父子节点数据返回
Oscrazy的博客
08-19 2000
java搜索树形结构数据,叶子节点并一起带父子节点数据返回
java递归与反向递归（逆向递归）查询树tree结构根据关键字过滤数据
热门推荐
leon-这个程序员不闷骚的博客
05-19 3万+
递归查询树tree结构有两种做法： 第一种，递归查询数据库结构，第二种，一次性将数据库表中的所有数据查出来，然后再递归查出来的list集合，第一种做法适合数据量较少的tree结构，因为要一直查询数据库数据量大时速度回相对较慢，所以数据量大时建议使用第二种方法 反向递归（逆向递归）查询树tree结构根据关键字过滤数据，大家有么有遇到过这个问题： 这是一个树结构，默认查询全部 我想要根
如何从树叶层开始建树？
xuexiaodong2009的专栏
09-27 5198
在开发软件的过程中，遇到一个树形结构的问题，如下图：             由于树形结构太大，只显示部分叶节点，并且报价是叶节点的数量和报价的成积。  问题经分析很显然：变成了如下两个问题： 1从树的根节点开始建树就是一个简单的递归，但现在的问题是从树的叶节点开始如何建树，涉及到一个如何合并子节点的问题。 2如何根据叶节点的数量和报价计算各级父节点的报价？
mysql递归查询所有父节点
05-26
在MySQL中，可以使用递归查询来查询所有父节点。假设有一个表格，其中包含id和parent_id两个列，表示每个节点的唯一标识和其父节点的唯一标识。下面是一个使用递归查询来查询所有父节点的示例： ``` WITH RECURSIVE cte (id, parent_id) AS ( SELECT id, parent_id FROM table_name WHERE id = 1 UNION ALL SELECT t.id, t.parent_id FROM table_name t INNER JOIN cte ON t.id = cte.parent_id ) SELECT id, parent_id FROM cte; ``` 在这个例子中，我们使用了CTE（公共表表达式）来定义递归查询。首先，我们查询id=1的节点作为起始点。然后，我们使用UNION ALL将起始节点和其所有父节点组合在一起。最后，我们从CTE中选择所有的id和parent_id。请注意，这个递归查询的停止条件是当没有更多的父节点时停止。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值