java递归构建树

java递归构建树形结构

万次阅读 2019-02-26 13:50:51

* 递归算法解析成树形结构 * * @param cid * @return * @author jiqinlin */ public TreeNode recursiveTree(int cid) { //根据cid获取节点对象(SELECT * FROM tb_tree t WHERE t.cid=?) TreeNode node = ...

只有一个根节点数据结构： 
1、准备表结构及对应的表数据
 a、表结构： 
create table TB_TREE
(
CID NUMBER not null,
CNAME VARCHAR2(50),
PID NUMBER //父节点
) 
b、表数据： 
 
insert into tb_tree (CID, CNAME, PID) values (1, '中国', 0);
insert into tb_tree (CID, CNAME, PID) values (2, '北京市', 1);
insert into tb_tree (CID, CNAME, PID) values (3, '广东省', 1);
insert into tb_tree (CID, CNAME, PID) values (4, '上海市', 1);
insert into tb_tree (CID, CNAME, PID) values (5, '广州市', 3);
insert into tb_tree (CID, CNAME, PID) values (6, '深圳市', 3);
insert into tb_tree (CID, CNAME, PID) values (7, '海珠区', 5);
insert into tb_tree (CID, CNAME, PID) values (8, '天河区', 5);
insert into tb_tree (CID, CNAME, PID) values (9, '福田区', 6);
insert into tb_tree (CID, CNAME, PID) values (10, '南山区', 6);
insert into tb_tree (CID, CNAME, PID) values (11, '密云县', 2);
insert into tb_tree (CID, CNAME, PID) values (12, '浦东', 4); 
 
2、TreeNode对象，对应tb_tree 
 
public class TreeNode implements Serializable {
private Integer cid;
private String cname;
private Integer pid;
private List nodes = new ArrayList();
 
public TreeNode() {
}
 
//getter、setter省略
} 
 
3、测试数据 
 
public class TreeNodeTest {
@Test
public void loadTree() throws Exception{
System.out.println(JsonUtils.javaToJson(recursiveTree(1)));
}
 
/**
* 递归算法解析成树形结构
*
* @param cid
* @return
* @author jiqinlin
*/
public TreeNode recursiveTree(int cid) {
//根据cid获取节点对象(SELECT * FROM tb_tree t WHERE t.cid=?)
TreeNode node = personService.getreeNode(cid);
//查询cid下的所有子节点(SELECT * FROM tb_tree t WHERE t.pid=?)
List childTreeNodes = personService.queryTreeNode(cid); 
//遍历子节点
for(TreeNode child : childTreeNodes){
TreeNode n = recursiveTree(child.getCid()); //递归
node.getNodes().add(n);
}
 
return node;
}
} 
 
输出的json格式如下： 
 
{
    "cid": 1,
    "nodes": [
        {
            "cid": 2,
            "nodes": [
                {
                    "cid": 11,
                    "nodes": [
                         
                    ],
                    "cname": "密云县",
                    "pid": 2
                }
            ],
            "cname": "北京市",
            "pid": 1
        },
        {
            "cid": 3,
            "nodes": [
                {
                    "cid": 5,
                    "nodes": [
                        {
                            "cid": 7,
                            "nodes": [
                                 
                            ],
                            "cname": "海珠区",
                            "pid": 5
                        },
                        {
                            "cid": 8,
                            "nodes": [
                                 
                            ],
                            "cname": "天河区",
                            "pid": 5
                        }
                    ],
                    "cname": "广州市",
                    "pid": 3
                },
                {
                    "cid": 6,
                    "nodes": [
                        {
                            "cid": 9,
                            "nodes": [
                                 
                            ],
                            "cname": "福田区",
                            "pid": 6
                        },
                        {
                            "cid": 10,
                            "nodes": [
                                 
                            ],
                            "cname": "南山区",
                            "pid": 6
                        }
                    ],
                    "cname": "深圳市",
                    "pid": 3
                }
            ],
            "cname": "广东省",
            "pid": 1
        },
        {
            "cid": 4,
            "nodes": [
                {
                    "cid": 12,
                    "nodes": [
                         
                    ],
                    "cname": "浦东",
                    "pid": 4
                }
            ],
            "cname": "上海市",
            "pid": 1
        }
    ],
    "cname": "中国",
    "pid": 0
} 
有多个根节点的树形结构： 
package com.forchain.platform.model;

import javax.persistence.*;

@Table(name = "tb_tree")
public class TbTree {

    @Id
    private Long cid;

    @Column(name = "CNAME")
    private String cname;

    @Column(name = "PID")
    private Long pid;

    /**
     * @return CID
     */
    public Long getCid() {
        return cid;
    }

    /**
     * @param cid
     */
    public void setCid(Long cid) {
        this.cid = cid;
    }

    /**
     * @return CNAME
     */
    public String getCname() {
        return cname;
    }

    /**
     * @param cname
     */
    public void setCname(String cname) {
        this.cname = cname;
    }

    /**
     * @return PID
     */
    public Long getPid() {
        return pid;
    }

    /**
     * @param pid
     */
    public void setPid(Long pid) {
        this.pid = pid;
    }
} 
/**
 * author   chong
 * 创建日期: 2019/2/26
 * 创建时间: 12:35
 */
@Getter
@Setter
public class TreeNode extends TbTree implements Serializable {

    List<List<TreeNode>> nodeList = new ArrayList<>();

} 
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.forchain.platform.mapper.TbTreeMapper">
  <resultMap id="BaseResultMap" type="com.forchain.platform.model.TbTree">
    <!--
      WARNING - @mbg.generated
    -->
    <result column="CID" jdbcType="BIGINT" property="cid" />
    <result column="CNAME" jdbcType="VARCHAR" property="cname" />
    <result column="PID" jdbcType="BIGINT" property="pid" />
  </resultMap>
  <select id="queryTreeNode" parameterType="java.lang.Long" resultType="com.forchain.platform.model.TreeNode">
    select * from tb_tree where PID =#{pId}
  </select>
</mapper> 
package com.forchain.platform.mapper;

import com.forchain.platform.config.mapper.BaseMapper;
import com.forchain.platform.model.TbTree;
import com.forchain.platform.model.TreeNode;

import java.util.List;

public interface TbTreeMapper extends BaseMapper<TbTree> {

    List<TreeNode> queryTreeNode(Long pId);

} 
create table tb_tree
 (
 CID BIGINT not null,
 CNAME VARCHAR(50),
 PID BIGINT
 ) 
insert into tb_tree (CID, CNAME, PID) values (1, '中国', NULL);
 insert into tb_tree (CID, CNAME, PID) values (2, '北京市', NULL);
 insert into tb_tree (CID, CNAME, PID) values (3, '广东省', NULL);
 insert into tb_tree (CID, CNAME, PID) values (4, '上海市', 1);
 insert into tb_tree (CID, CNAME, PID) values (5, '广州市', 1);
 insert into tb_tree (CID, CNAME, PID) values (6, '深圳市', 1);
 insert into tb_tree (CID, CNAME, PID) values (7, '海珠区', 1);
 insert into tb_tree (CID, CNAME, PID) values (8, '天河区', 2);
 insert into tb_tree (CID, CNAME, PID) values (9, '福田区', 2);
 insert into tb_tree (CID, CNAME, PID) values (10, '南山区', 3);
 insert into tb_tree (CID, CNAME, PID) values (11, '密云县', 3);
 insert into tb_tree (CID, CNAME, PID) values (12, '浦东', 3);
 insert into tb_tree (CID, CNAME, PID) values (13, '浦东22', 3);
 insert into tb_tree (CID, CNAME, PID) values (14, '浦东23', 4);
 insert into tb_tree (CID, CNAME, PID) values (15, '浦东24', 4);
 insert into tb_tree (CID, CNAME, PID) values (16, '浦东25', 6);
 insert into tb_tree (CID, CNAME, PID) values (17, '浦东25', 6);
 insert into tb_tree (CID, CNAME, PID) values (18, '浦东25', 6); 
@RunWith(SpringRunner.class)
@SpringBootTest
public class BcHrPlatformTest {

    @Resource
    TbTreeMapper tbTreeMapper;
    @Test
    public void loadTree() {
        System.err.println(JSONObject.toJSONString(recursiveTree(Long.parseLong(String.valueOf(0)))));
    }

    /**
     * 递归算法解析成树形结构
     */
    public List<TreeNode> recursiveTree(Long pId) {
        List<TreeNode> treeNodes = tbTreeMapper.queryTreeNode(pId);
        for (TreeNode node:treeNodes) {
            List<TreeNode> treeNodes1 = recursiveTree(node.getCid());
            if (!treeNodes1.isEmpty()) {
                node.getNodeList().add(treeNodes1);
            }
        }
        return treeNodes;
    }
} 
[{
     "cid": 1,
     "cname": "中国",
     "nodeList": [
         [{
             "cid": 4,
             "cname": "上海市",
             "nodeList": [
                 [{
                     "cid": 14,
                     "cname": "浦东23",
                     "nodeList": [],
                     "pid": 4
                 }, {
                     "cid": 15,
                     "cname": "浦东24",
                     "nodeList": [],
                     "pid": 4
                 }]
             ],
             "pid": 1
         }, {
             "cid": 5,
             "cname": "广州市",
             "nodeList": [],
             "pid": 1
         }, {
             "cid": 6,
             "cname": "深圳市",
             "nodeList": [
                 [{
                     "cid": 16,
                     "cname": "浦东25",
                     "nodeList": [],
                     "pid": 6
                 }, {
                     "cid": 17,
                     "cname": "浦东25",
                     "nodeList": [],
                     "pid": 6
                 }, {
                     "cid": 18,
                     "cname": "浦东25",
                     "nodeList": [],
                     "pid": 6
                 }]
             ],
             "pid": 1
         }, {
             "cid": 7,
             "cname": "海珠区",
             "nodeList": [],
             "pid": 1
         }]
     ],
     "pid": 0
 }, {
     "cid": 2,
     "cname": "北京市",
     "nodeList": [
         [{
             "cid": 8,
             "cname": "天河区",
             "nodeList": [],
             "pid": 2
         }, {
             "cid": 9,
             "cname": "福田区",
             "nodeList": [],
             "pid": 2
         }]
     ],
     "pid": 0
 }, {
     "cid": 3,
     "cname": "广东省",
     "nodeList": [
         [{
             "cid": 10,
             "cname": "南山区",
             "nodeList": [],
             "pid": 3
         }, {
             "cid": 11,
             "cname": "密云县",
             "nodeList": [],
             "pid": 3
         }, {
             "cid": 12,
             "cname": "浦东",
             "nodeList": [],
             "pid": 3
         }, {
             "cid": 13,
             "cname": "浦东22",
             "nodeList": [],
             "pid": 3
         }]
     ],
     "pid": 0
 }]

收起

展开全文

Java递归构建树形数据结构实现多级树形菜单展示

万次阅读 热门讨论 2018-06-15 17:46:16

首先看看需求，树形菜单是这样的：根据需求创建数据模型：构造树形数据结构：转为json数据看看结构是否正确：打完收工！

首先看看需求，树形菜单是这样的：

根据需求创建数据模型：

构造树形数据结构（Java8环境，Maps和Lists是用了谷歌的guava包）：

转为json数据看看结构是否正确：

打完收工！

2018-06-09修改，过滤map改为set

收起

展开全文

java 不使用递归构建树形结构

2021-10-13 00:42:22

java 不使用递归构建树形结构基本结构对象树形结构对象构建方法一般树形结构都包含两个关键字段，parentId,children，我的例子中使用的是parent对象,实际使用自己更改即可。基本结构对象 public class TreeBase<...



 java 不使用递归构建树形结构
 基本结构对象
树形结构对象
构建方法

 
一般树形结构都包含两个关键字段，parentId,children，我的例子中使用的是parent对象,实际使用自己更改即可。 
基本结构对象 
public class TreeBase<T> {
    @ApiModelProperty(value = "子集")
    private List<T> children;
    
    @ApiModelProperty(value = "父级id")
    private T parent;
	
	@ApiModelProperty(value = "id")
	private Long id;
}
 
上面这组对象是树形结构的基本结构，如果使用的父级结构是parentId就把 private T parent;改成pring String parentId;即可，另外，只要继承了该结构的对象，都可以调用下面的方法构建树形结构 
树形结构对象 
public class Permission extends TreeBase<Permission> {

    .....
    字段无需理会，实际使用不到
    .....

}
 
这是需要构建树形结构的对象，直接继承即可 
构建方法 
 public <T extends TreeBase<T>> List<T> listToTree(List<T> tList) {
        List<T> firstLabelDto = new ArrayList<>();
        Map<Long, T> labelMap = tList.stream().collect(Collectors.toMap(T::getId, v->v,(v1, v2)->v1));//将递归对象转化成map，方便查询
        for (T t : tList) {
            if (t.getParent() == null) {
                firstLabelDto.add(t);
            }
            else {
                labelMap.get(t.getParent().getId()).getChildren().add(t);
            }
        }
        return firstLabelDto;
    }
 
如果使用的是parentId，则在使用parent的位置相应更改即可，使用时直接调用，返回结果就是完整的树形结构

收起

展开全文

Java使用泛型递归构建树

2020-08-22 17:02:13

定义一个树实体 @Data public class Tree<T> { /** * 节点ID */ private String id; /** * 节点的子节点 */ private List<Tree<T>> children = new ArrayList<>(); /** * 父ID ...

定义一个树实体 
@Data
public class Tree<T> {
    /**
     * 节点ID
     */
    private String id;
    /**
     * 节点的子节点
     */
    private List<Tree<T>> children = new ArrayList<>();

    /**
     * 父ID
     */
    private String parentId;
     /**
     * 显示节点文本
     */
    private String text;
 
树工具类 
package com.yl.util.tree;


import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class TreeUtil {

   /**
    * 使用递归方法建树
    *
    * @param modules
    * @return
    */
   public static <T> List<Tree<T>> buildByRecursive(List<Tree<T>> modules, String pId) {
       List<Tree<T>> trees = new ArrayList<>();
       for (Tree<T> treeNode : modules) {
           if (pId.equals(treeNode.getParentId())) {
               trees.add(findChildren(treeNode, modules));
           }
       }

       return trees;
   }

   /**
    * 递归查找子节点
    *
    * @param treeNodes
    * @return
    */
   public static <T> Tree<T> findChildren(Tree<T> treeNode, List<Tree<T>> nodes) {
       for (Tree<T> it : nodes) {
           if (treeNode.getId().equals(it.getParentId())) {
               if (treeNode.getChildren() == null) {
                   treeNode.setChildren(new ArrayList<>());
               }
               treeNode.getChildren().add(findChildren(it, nodes));
           }
       }
       return treeNode;
   }
}
 
调用 
public List<Tree<NoticeType>> getTree() {
        List<Tree<NoticeType>> trees = new ArrayList<>();
        List<NoticeType> list = noticeTypeMapper.selectAll();
        buildTrees(trees,list);
        return TreeUtil.buildByRecursive(trees,"0");
    }

    private void buildTrees(List<Tree<NoticeType>> trees,List<NoticeType> noticeTypes){
        noticeTypes.forEach(noticeTypes -> {
            Tree<NoticeType> tree = new Tree<>();
            tree.setId(noticeTypes.getId().toString());
            tree.setParentId(noticeTypes.getParentId().toString());
            tree.setText(noticeTypes.getName());
            trees.add(tree);
        });
    }

收起

展开全文

java-递归构建目录树结构
2020-12-21 10:36:23
java-递归构建目录树结构注意：实体中需要有一个属性判断当前节点是否含有孩子节点，递归方法会根据该标识停止，该属性一旦有误将会陷入死循环 public List<EffectEvaluation> getEffectEvaluationTree...
收起
java使用递归方法构建树
2021-01-21 17:02:10
java递归语法使用java递归语法使用node类使用递归方法建树 java递归语法使用你好！ node实体类递归建tree。 node类 @Data public class TIotSysArea { private Long id; private String name; private String...
收起
java list 内递归构建树，效率很差，如果remove节点报ConcurrentModificationException
2019-05-23 10:50:55
//转换树对象 //根节点 List<AynpTree> treeRootList = (List) CollectionUtils.select(dataList, new Predicate() { @Override public boolean evaluate(Object object) { AynpTree ay = (AynpTree) ...
收起
java 递归实现权限树（菜单树）
千次阅读 多人点赞 2019-12-18 17:56:12
java 递归实现权限树（菜单树）省市县多级结构
收起
Java递归算法构造JSON树形结构
2017-10-20 16:56:47
Java递归算法构造JSON树形结构，Java递归算法构造JSON树形结构Java递归算法构造JSON树形结构
收起
递归构建一整棵树
2018-07-24 11:26:57
通过递归方法构建树形结构数据，比如无限层级菜单，可供新手学习递归算法
收起
【java递归生成树形结构】
2020-04-24 15:29:58
项目开发中，几乎无法避免的会遇到树形结构，今天和大家分享java后端如何处理数据为树形结构。前端处理树形结构，后端生成树形结构。 Entity实体层：此处省略好几个实体字段。 /** * 孩子节点集合 */ ...
收起
java构建树，构建tree，组装树结构，通用算法，用到递归算法
万次阅读 2017-06-10 09:09:18
请跟着main方法走，然后看代码注释。...import java.util.ArrayList; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.ut...
收起
算法
java递归生成菜单树
2020-06-04 16:57:50
递归组装树形结构函数实现 mysql表数据自行准备 CREATE TABLE `sys_menu` ( `id` int(11) NOT NULL AUTO_INCREMENT, `pid` bigint(20) DEFAULT NULL, `title` varchar(255) CHARACTER SET utf8 DEFAULT NULL...
收起
Java & JavaScript 递归构建树状图（根据parentId）
2021-06-07 19:51:34
JavaScript 递归构建树状图（根据parentId）类似于实现这样的效果实现思路：第一步：找到所有根节点（parentId == null）第二步：遍历跟结点，递归生成根节点的子树 1.1 JavaScript 实现 export class ...
收起
js 数据结构
JAVA递归生成tree树
千次阅读 2015-06-01 09:37:46
关于类别树的多级是一个刚接触ajax和多级类别很头痛的问题,针对那种商品种类繁多,级别层次多更是麻烦的问题,去年刚学asp.net,实验室的同学曾经这样做过,递归sql,现在看了惊心动魄虽然实现了类别多级的问题这样...
收起
用递归构建组织树
2015-10-22 17:29:22
/** * 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—stream流递归实现树形结构
千次阅读 2020-09-28 18:49:38
stream流递归实现树形结构
收起
steam流
java+mysql递归拼接树形JSON列表
万次阅读 2017-05-26 13:52:52
java+mysql递归拼接树形JSON列表
收起
mysql json
Java递归实现删除树形结构的任一节点
千次阅读 2015-11-07 16:30:27
要删除树形结构的节点，需考虑两件事: 1.要删除的节点若包含子节点，则需删除...要遍历树形结构中的一个节点及其子节点，采用递归会比较方便，首先需要一个方法，来将这两件事包含在一起，于是要构建一个方法delClasse
收起
事务

java递归构建树形结构

Java递归构建树形数据结构实现多级树形菜单展示

java 不使用递归构建树形结构

java 不使用递归构建树形结构

基本结构对象

树形结构对象

构建方法

Java使用泛型递归构建树

java-递归构建目录树结构

java使用递归方法构建树

java list 内递归构建树，效率很差，如果remove节点报ConcurrentModificationException

java 递归实现权限树（菜单树）

Java递归算法构造JSON树形结构

递归构建一整棵树

【java递归生成树形结构】

java构建树，构建tree，组装树结构，通用算法，用到递归算法

java递归生成菜单树

Java & JavaScript 递归构建树状图（根据parentId）

JAVA递归生成tree树

用递归构建组织树

java—stream流递归实现树形结构

java+mysql递归拼接树形JSON列表

Java递归实现删除树形结构的任一节点

java递归构建树