精华内容
下载资源
问答
  • java树状结构

    2013-05-13 10:17:18
    java树状结构添加删除
  • Java 树状结构

    2008-07-05 12:59:07
    Java树状结构 Java树状结构
  • JAVA树状结构转List平面 使用递归实现 #主方法 A 实体, @ApiModel(value = "A", description = "信息") @Data public class A{ /** * bod编码 */ @ApiModelProperty(value = "bod编码", hidden = true) @...

    JAVA树状结构转List平面

    使用递归实现

    #主方法
    A 实体,
    @ApiModel(value = "A", description = "信息")
    @Data
    public  class A{
    
        @ApiModelProperty(value = "级别,从1开始")
    	private  String level;
    	
    	@ApiModelProperty(value = "父节点编码")
        @Size(max = 30)
        @NotNull
    	private String parentNode ;
    	
    	 @ApiModelProperty(value = "子节点集合")
        @Valid
        List<A> children;
    }
    
    ##实现类
      //树转list 
      List<A> needSaveList = new ArrayList<>(16);
      //递归
      createBodNodeList(needSaveList, null, X.getChildren(), 0);
    
    /**
     * 树转list
     */
    private void createBodNodeList(List<A> needSaveList, BodNodesAdd parentNode, List<A> children, int level, String bodNo) {
        if (children == null || children.size() == 0) {
            return;
        }
        level++;
        for (A  inWarehouse : children) {
            A   needSaveNode= BeanUtils.convert(inWarehouse, A.class);
            needSaveNode.setParentNodeNo(parentNode == null ? "" : parentNode.getNodeNo());
            needSaveNode.setLevel(level);
            needSaveList.add(needSaveBodNode);
            createBodNodeList(needSaveList, inWarehouse, inWarehouse.getChildren(), level);
        }
    }
    
    
    展开全文
  • 场景树状结构的菜单数据,封装好提供给前端.核心方法:mergeList()前置条件:节点具有层级信息import lombok.Data;import java.io.Serializable;import java.util.ArrayList;import java.util.Collections;import java....

    场景

    树状结构的菜单数据,封装好提供给前端.

    核心方法:mergeList()

    前置条件:节点具有层级信息

    import lombok.Data;

    import java.io.Serializable;

    import java.util.ArrayList;

    import java.util.Collections;

    import java.util.HashMap;

    import java.util.LinkedList;

    import java.util.List;

    import java.util.Map;

    @Data

    public class MenuNode implements Comparable, Serializable {

    /**

    * 节点id

    */

    private Long id;

    /**

    * 父节点

    */

    private Long parentId;

    /**

    * 节点名称

    */

    private String name;

    /**

    * 节点层级

    */

    private Integer level;

    /**

    * 菜单的类型 1 系统 2菜单 3 按钮

    */

    private Integer type;

    /**

    * 节点的排序

    */

    private Integer num;

    /**

    * 节点的url

    */

    private String url;

    /**

    * 节点图标

    */

    private String icon;

    /**

    * 子节点的集合

    */

    private List children;

    /**

    * 查询子节点时候的临时集合

    */

    private List linkedList = new ArrayList<>();

    public MenuNode() {

    super();

    }

    public MenuNode(Long id, Long parentId) {

    super();

    this.id = id;

    this.parentId = parentId;

    }

    /**

    * 重写排序比较接口,首先根据等级排序,然后更具排序字段排序

    *

    * @param o

    * @return

    */

    @Override

    public int compareTo(Object o) {

    MenuNode menuNode = (MenuNode) o;

    Integer num = menuNode.getNum();

    Integer levels = menuNode.getLevel();

    if (num == null) {

    num = 0;

    }

    if (levels == null) {

    levels = 0;

    }

    if (this.level.compareTo(levels) == 0) {

    return this.num.compareTo(num);

    } else {

    return this.level.compareTo(levels);

    }

    }

    /**

    * 构建页面菜单列表

    */

    public static List buildTitle(List nodes) {

    if (nodes.size() <= 0) {

    return nodes;

    }

    //剔除非菜单

    nodes.removeIf(node -> !node.getType().equals(BaseIntegerEnum.MENU_TYPE_IS_MENU.getValue()));

    //对菜单排序,返回列表按菜单等级,序号的排序方式排列

    Collections.sort(nodes);

    return mergeList(nodes, nodes.get(nodes.size() - 1).getLevel(), null);

    }

    /**

    * 递归合并数组为子数组,最后返回第一层

    *

    * @param menuList

    * @param listMap

    * @return

    */

    private static List mergeList(List menuList, int rank, Map> listMap) {

    //保存当次调用总共合并了多少元素

    int n;

    //保存当次调用总共合并出来的list

    Map> currentMap = new HashMap<>();

    //由于按等级从小到大排序,需要从后往前排序

    //判断该节点是否属于当前循环的等级,不等于则跳出循环

    for (n = menuList.size() - 1; n >= 0 && menuList.get(n).getLevel() == rank; n--) {

    //判断之前的调用是否有返回以该节点的id为key的map,有则设置为children列表。

    if (listMap != null && listMap.get(menuList.get(n).getId()) != null) {

    menuList.get(n).setChildren(listMap.get(menuList.get(n).getId()));

    }

    if (menuList.get(n).getParentId() != null && menuList.get(n).getParentId() != 0) {

    //判断当前节点所属的pid是否已经创建了以该pid为key的键值对,没有则创建新的链表

    currentMap.computeIfAbsent(menuList.get(n).getParentId(), k -> new LinkedList<>());

    //将该节点插入到对应的list的头部

    currentMap.get(menuList.get(n).getParentId()).add(0, menuList.get(n));

    }

    }

    if (n < 0) {

    return menuList;

    } else {

    return mergeList(new ArrayList<>(menuList.subList(0, n + 1)), menuList.get(n).getLevel(), currentMap);

    }

    }

    }

    展开全文
  • JAVA树状结构格式转换及节点提取功能说明实现步骤1、创建节点抽象类2、创建树状结构实体类3、创建抽象类实现4、创建工具类效果图转换前平铺数据执行convertToTreeList()转换后树状数据执行convertToObjList()树状...

    功能说明

    1、将整棵树状结构对象分解成可直接读取节点的普通对象列表
    2、将仅有当前节点和父节点的对象列表整合成树状结构数据对象
    3、根据第一点直接读取指定节点的详细数据信息

    实现步骤

    1、创建节点抽象类

    创建节点抽象类,用户可自定义类继承此抽象类,数据转换时使用

    package entity;
    
    /**
     * 平铺数据结构方法
     */
    public interface TreeSourceNode {
        //    获取节点ID
        public abstract String getId();
    
        //    获取节点名称
        public abstract String getName();
    
        //    获取父节点ID
        public abstract String getParentId();
    
    }
    
    

    2、创建树状结构实体类

    package entity;
    
    import java.util.List;
    
    /**
     * 树形结构节点
     */
    public class TreeStructure {
        //唯一标识
        private String id;
        //名称
        private String name;
        //父节点
        private String parentId;
        //级别
        private int level;
        //子节点
        private List<TreeStructure> children;
    
        public String getId() {
            return id;
        }
        public void setId(String id) {
            this.id = id;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public String getParentId() {
            return parentId;
        }
        public void setParentId(String parentId) {
            this.parentId = parentId;
        }
        public List<TreeStructure> getChildren() {
            return children;
        }
        public void setChildren(List<TreeStructure> children) {
            this.children = children;
        }
        public int getLevel() {
            return level;
        }
        public void setLevel(int level) {
            this.level = level;
        }
    }
    
    

    3、创建抽象类实现

    package example;
    
    
    import entity.TreeSourceNode;
    
    /**
     * @Description: 机型节点实体
     * @Author: ld
     * @Date: 2021-01-16 16:17
     */
    public class ActTypeNodeVo implements TreeSourceNode {
    
        private String parentId;
        private String id;
        private String name;
        private String level;
    
        @Override
        public String getParentId() {
            return parentId;
        }
    
        public void setParentId(String parentId) {
            this.parentId = parentId;
        }
    
        @Override
        public String getId() {
            return id;
        }
    
        public void setId(String id) {
            this.id = id;
        }
    
        @Override
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getLevel() {
            return level;
        }
    
        public void setLevel(String level) {
            this.level = level;
        }
    }
    
    

    4、创建工具类

    package utile;
    
    import entity.TreeStructure;
    import entity.TreeTileNode;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * @Description: 树状结构工具类
     * @Author: ld
     * @Date: 2021-01-28 17:55
     */
    public class TreeHelper {
    
        private TreeHelper(){
    
        }
            /**
             * 获取指定树状结构中的某节点的详细数据
             * @param treeStructureList 指定树状结构列表数据
             * @param nodeId  指定节点id
             * @return 指定id的详细数据
             */
            public static  TreeStructure getNode(List<TreeStructure> treeStructureList, String nodeId) {
    
                for (TreeStructure obj: convertToTileList(treeStructureList)) {
                    if(nodeId.equals(obj.getId())){
                        return obj;
                    }
                }
                return null;
            }
    
        /**
         * 将树状结构转换为平铺数据结构(将含有children的树状结构转换为仅有节点和父节点的对象列表)
         * @param source 树状结构数据列表
         * @return 平铺数据结构列表
         */
        public static List<TreeStructure> convertToTileList(List<TreeStructure> source){
            List<TreeStructure> outList = new ArrayList<>();
            for (TreeStructure tTreeStructure : source) {
                if (tTreeStructure.getChildren() != null) {
                    List<TreeStructure> treeStructureList = tTreeStructure.getChildren();
                    outList.add(tTreeStructure);
                    convertChildrenToTileList(treeStructureList, outList);
                    //若不需要字节点,则可设置为空
                  //  tTreeStructure.setChildren(null);
                } else {
                    outList.add(tTreeStructure);
                }
            }
            return outList;
        }
    
    
            /**
             * 将树状结构转换为平铺数据结构(将含有children的树状结构转换为仅有节点和父节点的对象列表)
             * @param source 树状结构数据列表
             * @param outList 平铺数据结构列表
             */
            private static void convertChildrenToTileList(List<TreeStructure> source , List<TreeStructure> outList){
                if(outList==null){
                    outList = new ArrayList<>();
                }
                for (TreeStructure tTreeStructure : source) {
                    if (tTreeStructure.getChildren() != null) {
                        List<TreeStructure> treeStructureList = tTreeStructure.getChildren();
                        outList.add(tTreeStructure);
                        convertChildrenToTileList(treeStructureList, outList);
                        //若不需要字节点,则可设置为空
                        //  tTreeStructure.setChildren(null);
                    } else {
                        outList.add(tTreeStructure);
                    }
                }
            }
    
            /**
             * 平铺数据建立成树(将仅有节点和父节点的对象列表转换为含有children的树状结构)
             * @param tileStructureList 平铺数据列表
             * @param <T> 任意
             * @return 树状结构数据
             */
            public static <T extends TreeTileNode> List<TreeStructure> convertToTreeList(List<T> tileStructureList) {
                List<TreeStructure> treeStructureList = new ArrayList<>();
                List<String> allIds = new ArrayList<>();
                for (T sourceNode : tileStructureList) {
                    allIds.add(sourceNode.getId());
                }
                for (T tileNode : tileStructureList) {
                    if (!allIds.contains(tileNode.getParentId())) {
                        TreeStructure treeStructure = new TreeStructure();
                        treeStructure.setId(tileNode.getId());
                        treeStructure.setName(tileNode.getName());
                        //第一层设置等级为1
                        treeStructure.setLevel(1);
                        treeStructure.setParentId(tileNode.getParentId());
                        List<TreeStructure> children = convertChildrenToTreeList(tileStructureList, treeStructure);
                        treeStructure.setChildren(children.isEmpty() ? null : children);
                        treeStructureList.add(treeStructure);
                    }
                }
                return treeStructureList;
            }
    
            private static <T extends TreeTileNode> List<TreeStructure> convertChildrenToTreeList(List<T> tileStructureList, TreeStructure node) {
                List<TreeStructure> childrenList = new ArrayList<>();
                for (T tileNode : tileStructureList) {
                    if (node.getId().equals(tileNode.getParentId())) {
                        TreeStructure treeStructure = new TreeStructure();
                        treeStructure.setId(tileNode.getId());
                        treeStructure.setName(tileNode.getName());
                        treeStructure.setLevel(node.getLevel() + 1);
                        treeStructure.setParentId(tileNode.getParentId());
                        List<TreeStructure> children = convertChildrenToTreeList(tileStructureList, treeStructure);
                        treeStructure.setChildren(children.isEmpty() ? null : children);
                        childrenList.add(treeStructure);
                    }
                }
                return childrenList;
            }
        }
    
    

    效果图

    转换前平铺数据

    数据含有当前id与父节点id
    在这里插入图片描述

    执行convertToTreeList()转换后树状数据

    将上面的列表转换成树状结构,父子节点关联构成树状结构
    在这里插入图片描述

    执行convertToObjList()树状结构转换成平铺对象

    将上边的树状结构图转换成平铺对象列表
    若不需要子节点children,可以在代码中设置setChildren(null)
    在这里插入图片描述

    执行getNode()获取指定节点数据

    自己调用下方法试试

    展开全文
  • Java树状结构实现BBS

    2010-08-29 20:07:31
    实现一个BBS可以采取多种方法,该项目采用树状结构来实现,用户可以很容易看出谁回复了谁,自己要回复谁也很方便.对于管理员来说,登陆管理员页面可以进行数据的增、删、查、改,项目中使用了多种分页的写法.
  • dtree在生成简单树方面比使用Jquery的treeView要方便,代码实现的是用户选择的树状结构图。
  • 在此之间先说一个概念,广义表一、广义表广义表是一种非线性的数据结构,广义表是n个数据元素d1,d2,d3,…,dn的有限序列,但线性表不同的是,广义表中的di 则既可以是单个元素,还可以是一个广义表,通常记作:GL...

    前面已经提到过树和二叉树的相关概念内容,下面主要来介绍下关于二叉树的创建,遍历,查找等相关内容。在此之间先说一个概念,广义表

    一、广义表

    广义表是一种非线性的数据结构,广义表是n个数据元素d1,d2,d3,…,dn的有限序列,但线性表不同的是,广义表中的di 则既可以是单个元素,还可以是一个广义表,通

    常记作:GL=(d1,d2,d3,…,dn)。GL是广义表的名字,通常广义表的名字用大写字母表示。n是广义表的长度。若其中di是一个广义表,则称di是广义表GL的子表。在

    广义表GL中,d1是广义表GL的表头,而广义表GL其余部分组成的表(d2,d3,…,dn)称为广义表的表尾。由此可见广义表的定义是递归定义的。

    二、创建二叉树

    采用广义表的方式创建二叉树。创建的二叉树结构如下:

    0ed0606d9fde319d422caadad5b6175f.png

    1 定义Node节点

    public class Node {

    private char data;

    private Node lchild;

    private Node rchild;

    public Node(){

    }

    public char getData() {

    return data;

    }

    public void setData(char data) {

    this.data = data;

    }

    public Node getRchild() {

    return rchild;

    }

    public void setRchild(Node rchild) {

    this.rchild = rchild;

    }

    public Node getLchild() {

    return lchild;

    }

    public void setLchild(Node lchild) {

    this.lchild = lchild;

    }

    public Node(char ch, Node rchild, Node lchild) {

    this.data = ch;

    this.rchild = rchild;

    this.lchild = lchild;

    }

    public String toString() {

    return "" + getData();

    }

    }2. 二叉树创建类

    Node createTree(String express, char split){

    String[] array = StringUtils.split(express, split);

    int length = array.length-1;

    int capicity = (1<

    Node[] nodes = new Node[capicity];

    Node head =null;

    Node p = null;

    int level = -1;

    int childType = 0;

    int index =0;

    char data;

    char[] charArray = express.toCharArray();

    while(index < charArray.length-1){

    data = charArray[index];

    switch(data){

    case '(':

    level++;

    childType = 1;

    nodes[level]=p;

    break;

    case ',':

    childType = 2;

    break;

    case ')':

    level--;

    break;

    default:

    p = new Node(data, null, null);

    if(head == null){

    head = p;

    break;

    }else{

    switch(childType){

    case 1: nodes[level].setLchild(p);break;

    case 2: nodes[level].setRchild(p);break;

    }

    }

    }

    data = charArray[++index];

    }

    return head;

    }

    三、二叉树的遍历

    1. 先序遍历

    此种遍历模式是先读取父节点,然后再读取左右节点。

    1.1 递归先序遍历

    /**

    * 递归先序遍历

    * @param node

    */

    public void preTraversal(Node node){

    if(null == node){

    return;

    }else{

    System.out.print(node.getData()+" ");

    preTraversal(node.getLchild());

    preTraversal(node.getRchild());

    }

    }

    1.2 非递归先序遍历

    /**

    * 非递归先序遍历

    * @param node

    */

    public void preTraversalNoRecursive(Node node){

    if(null == node){

    return;

    }

    Node p = null;

    int level=0;

    Node[] stack = new Node[1024];

    stack[0] = node;//先将树根节点压入栈中

    while(level > -1){

    p = stack[level];

    level--;//移除栈的顶层节点

    System.out.print(p.getData()+" ");

    if(null != p.getRchild()){//如果树右子节点不为null,则压入栈中

    stack[++level] = p.getRchild();

    }

    if(null != p.getLchild()){//如果树左子节点不为Null,则压入栈中

    stack[++level] = p.getLchild();

    }

    }

    }

    2. 中序遍历

    此种遍历模式是先读取左子节点,然后读取父节点,最后读取右节点。

    2.1  递归中序遍历

    /**

    * 递归中序遍历

    * @param node

    */

    public void midTraversal(Node node){

    if(null == node){

    return;

    }else{

    midTraversal(node.getLchild());

    System.out.print(node.getData()+" ");

    midTraversal(node.getRchild());

    }

    }

    2.2 非递归中序遍历

    /**

    * 非递归中序遍历

    * @param node

    */

    public void midTraversalNoRecursive(Node node){

    if(null == node){

    return;

    }

    int level = -1;

    Node[] stack = new Node[1024];

    Node p = node;

    while(p != null || level > -1){//节点不为null或则当前层数不为-1

    while(p != null){

    stack[++level] = p;//将p压入栈

    p = p.getLchild();//获取p的左子结点

    }

    if(level > -1){

    p = stack[level];//获取栈顶层节点

    level--;

    System.out.print(p.getData()+" ");

    p = p.getRchild();//读取为最下方的左子节点,接着访问该节点的右子节点

    }

    }

    }

    3. 后序遍历

    此种遍历模式是先读取左右节点,然后再读取父节点。

    3.1 递归后序遍历

    /**

    * 递归后序遍历

    * @param node

    */

    public void lastTraversal(Node node){

    if(null == node){

    return;

    }else{

    lastTraversal(node.getLchild());

    lastTraversal(node.getRchild());

    System.out.print(node.getData()+" ");

    }

    }4. 二叉树的深度遍历

    待补充

    5. 二叉树的广度遍历

    待补充

    展开全文
  • java树状结构之二叉树

    2014-10-10 13:01:23
    广义表是一种非线性的数据结构,广义表是n个数据元素d1,d2,d3,…,dn的有限序列,但线性表不同的是,广义表中的di 则既可以是单个元素,还可以是一个广义表,通 常记作:GL=(d1,d2,d3,…,dn)。GL是广义...
  • java查询树状结构

    千次阅读 2019-07-22 13:24:00
    一直以来树状结构都不是特别好做,现在给一套通用的做法 例如: mybatis里面: <select id="getDistricts" resultType="com.swcote.district.entity.District"> SELECT id, code, name, gr...
  • java集合树状结构及源码

    千次阅读 2017-09-17 14:44:22
    java集合树状结构及源码
  • java拼接树状结构数据

    2020-06-10 15:52:23
    1.在domain实体类里面加上一个字段(前台需要的树状结构字段) //这里前台需要的是children 类型的树状结构 private List<CourseType> children = new ArrayList<>(); 2.在service层里面查询所有数据,...
  • This is what I've tried so far: import java.util.*; class Materials { public int id; public String content; public int pid; public Materials(int id, String content, int pid) { this.id = id; this....
  • Java构建树状结构

    千次阅读 2019-05-19 01:06:28
    * 树状结构生生成 * @author Administrator * */ public class NodesUtils { //判断是否根节点,可根据实际情况修改 public static boolean isRootElement(Nodes node){ if(node.getPid().equals("0")){ ...
  • 查询数据库组装成树状结构数据(学习笔记)数据库careate table category{id int PRIMARY KEY COMMENT '主键',level int COMMENT '等级',category_name varchar(7) COMMENT '类目名',parent_id int COMMENT '父节点id'...
  • Java实现树状结构数据的封装

    千次阅读 2020-01-19 17:56:50
    需求:前端的树状目录需要后端响应树形结构json数据,所以需要后端将数据封装成树状结构数据,然后restful接口传递到前端。 步骤一:创建树状结构对象 /** * 树状对象封装类 */ @Data public class TreeObject ...
  • 之前对于树状结构的处理没什么困难,但是最近的一个需求就很麻烦。其实遍历出树状结构并不是什么困难的事情,但是这个需求需要从底层节点统计数量,然后向上修改所有的父级结构。最难的地方就是这个地方,可能有的子...
  • 关于树状结构数据构建文章有很多,但是通常网上的都会涉及到数据的大量遍历来完成; 实际上当你构建的树数据量过大时就可能出现超时问题,导致无法正常进行; 正好遇到了这种500多条数据,然后用正常的方法时会...
  • Java递归实现树状结构

    千次阅读 2016-10-07 15:00:16
    只是简单实现树状结构,后续进行补充。package com.tree.test; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql....
  • oracle 11g树形结构java代码以及结果是本文探讨的主要内容。一、start with org_id = '条件1' prior parent_id = son_id; 的作用这个就是为了把树形结构全部查出来,树的目录就放在同一张表中,如1|--2|--3|--4|--5|-...
  • 树状结构工具 创建类TreeUtil 类属性 private List<T> rootList; //根节点对象存放到这里 private List<T> bodyList; //其他节点存放到这里,可以包含根节点 private Function<T,Object> ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,038
精华内容 415
关键字:

java树状结构

java 订阅