java树形结构存储_java树形结构 算法【收藏】

最新推荐文章于 2022-09-05 16:05:26 发布
最新推荐文章于 2022-09-05 16:05:26 发布
阅读量544 收藏
点赞数
文章标签： java树形结构存储
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39728221/article/details/114250278
版权
本文介绍了如何使用Java实现树形结构的存储和操作，包括新增、修改和删除节点的详细步骤。通过调整节点的左右值（lft和rgt）来维护树的平衡。新增节点时，首先找到父节点的lft值，然后更新所有受影响的节点；修改节点时，需要考虑旧父节点和新父节点的影响，调整多个位置；删除节点时，只需减小大于删除节点lft值的节点的lft和rgt。所有操作均涉及对数据库中节点数据的更新。
摘要由CSDN通过智能技术生成

2be4e28de31a69b778ae054f46a69123.png这样我们查找该节点的所有子节点，则只需要查找id在lft和rgt之间的所有节点即可。

1.查找该节点的所有子节点的Sql语句为：

Sql代码 icon_copy.gif

select*fromtb_subject s,tb_subject twheres.lftbetweent.lftandt.rgtandt.id=1

select * from tb_subject s,tb_subject t where s.lft between t.lft and t.rgt and t.id=1

2.查找该节点的所有父节点的sql语句为：

Sql代码 icon_copy.gif

selects.*fromtb_subject s,tb_subject twheres.lft1ands.rgt>t.rgtandt.id=1

select s.* from tb_subject s,tb_subject t where s.lft1 and s.rgt>t.rgt and t.id=1

下面来详细讲解下，怎么用java来实现这种算法。

1.新增节点

新增节点比较简单，基本步骤为

A．查找当前插入节点的父节点的lft值

B．将树形中所有lft和rgt节点大于父节点左值的节点都+2

C．将父节点左值+1，左值+2分别作为当前节点的lft和rgt

因为项目中采用的是struts2+hibernate3.2+spring2.5的框架，代码如下：

Java代码 icon_copy.gif

publicbooleanonSave(Object entity, Serializable id, Object[] state,

String[] propertyNames, Type[] types) {

if(entityinstanceofHibernateTree) {

HibernateTree tree = (HibernateTree) entity;

Long parentId = tree.getParentId();

String beanName = tree.getClass().getName();

Session session = getSession();

FlushMode model = session.getFlushMode();

session.setFlushMode(FlushMode.MANUAL);

Integer myPosition =newInteger(0);

//查找父节点的左值

if(parentId !=null) {

String hql ="select b.lft from "+ beanName

+" b where b.id=:pid";

myPosition = (Integer) session.createQuery(hql).setLong("pid",

parentId).uniqueResult();

}

//将树形结构中所有大于父节点左值的右节点+2

String hql1 ="update "+ beanName

+" b set b.rgt = b.rgt + 2 WHERE b.rgt > :myPosition";

//将树形结构中所有大于父节点左值的左节点+2

String hql2 ="update "+ beanName

+" b set b.lft = b.lft + 2 WHERE b.lft > :myPosition";

if(!StringUtils.isBlank(tree.getTreeCondition())) {

hql1 +=" and ("+ tree.getTreeCondition() +")";

hql2 +=" and ("+ tree.getTreeCondition() +")";

}

session.createQuery(hql1).setInteger("myPosition", myPosition)

.executeUpdate();

session.createQuery(hql2).setInteger("myPosition", myPosition)

.executeUpdate();

session.setFlushMode(model);

//定位自己的左值(父节点左值+1)和右值(父节点左值+2)

for(inti =0; i 

if(propertyNames[i].equals(HibernateTree.LFT)) {

state[i] = myPosition +1;

}

if(propertyNames[i].equals(HibernateTree.RGT)) {

state[i] = myPosition +2;

}

}

returntrue;

}

returnfalse;

}

public boolean onSave(Object entity, Serializable id, Object[] state,

String[] propertyNames, Type[] types) {

if (entity instanceof HibernateTree) {

HibernateTree tree = (HibernateTree) entity;

Long parentId = tree.getParentId();

String beanName = tree.getClass().getName();

Session session = getSession();

FlushMode model = session.getFlushMode();

session.setFlushMode(FlushMode.MANUAL);

Integer myPosition = new Integer(0);

//查找父节点的左值

if (parentId != null) {

String hql = "select b.lft from " + beanName

+ " b where b.id=:pid";

myPosition = (Integer) session.createQuery(hql).setLong("pid",

parentId).uniqueResult();

}

//将树形结构中所有大于父节点左值的右节点+2

String hql1 = "update " + beanName

+ " b set b.rgt = b.rgt + 2 WHERE b.rgt > :myPosition";

//将树形结构中所有大于父节点左值的左节点+2

String hql2 = "update " + beanName

+ " b set b.lft = b.lft + 2 WHERE b.lft > :myPosition";

if (!StringUtils.isBlank(tree.getTreeCondition())) {

hql1 += " and (" + tree.getTreeCondition() + ")";

hql2 += " and (" + tree.getTreeCondition() + ")";

}

session.createQuery(hql1).setInteger("myPosition", myPosition)

.executeUpdate();

session.createQuery(hql2).setInteger("myPosition", myPosition)

.executeUpdate();

session.setFlushMode(model);

//定位自己的左值(父节点左值+1)和右值(父节点左值+2)

for (int i = 0; i < propertyNames.length; i++) {

if (propertyNames[i].equals(HibernateTree.LFT)) {

state[i] = myPosition + 1;

}

if (propertyNames[i].equals(HibernateTree.RGT)) {

state[i] = myPosition + 2;

}

}

return true;

}

return false;

}

２.修改节点

修改的时候比较麻烦，具体步骤为：

在修改lft和rgt之前，当前节点的父节点id已经改变

a.查出当前节点的左右节点(nodelft、nodergt)，并nodergt-nodelft+1 = span，获取父节点的左节点parentlft

b.将所有大于parentlft的lft(左节点)、rgt(右节点)的值+span

c.查找当前节点的左右节点(nodelft、nodergt)，并parentlft-nodelft+1 = offset

d.将所有lft(左节点) between nodelft and nodergt的值+offset

e.将所有大于nodergt的lft(左节点)、rgt(右节点)的值-span

Java代码如下：

Java代码 icon_copy.gif

publicvoidupdateParent(HibernateTree tree, HibernateTree preParent,

HibernateTree curParent) {

if(preParent !=null&& preParent !=null

&& !preParent.equals(curParent)) {

String beanName = tree.getClass().getName();

// 获得节点位置

String hql ="select b.lft,b.rgt from "+ beanName

+" b where b.id=:id";

Object[] position = (Object[])super.createQuery(hql).setLong(

"id", tree.getId()).uniqueResult();

System.out.println(hql+"| id = "+tree.getId());

intnodeLft = ((Number) position[0]).intValue();

intnodeRgt = ((Number) position[1]).intValue();

intspan = nodeRgt - nodeLft +1;

// 获得当前父节点左位置

hql ="select b.lft from "+ beanName +" b where b.id=:id";

intparentLft = ((Number)super.createQuery(hql).setLong("id",

curParent.getId()).uniqueResult()).intValue();

System.out.println(hql+"| id = "+curParent.getId());

// 先空出位置

String hql1 ="update "+ beanName +" b set b.rgt = b.rgt + "

+ span +" WHERE b.rgt > :parentLft";

String hql2 ="update "+ beanName +" b set b.lft = b.lft + "

+ span +" WHERE b.lft > :parentLft";

if(!StringUtils.isBlank(tree.getTreeCondition())) {

hql1 +=" and ("+ tree.getTreeCondition() +")";

hql2 +=" and ("+ tree.getTreeCondition() +")";

}

super.createQuery(hql1).setInteger("parentLft", parentLft)

.executeUpdate();

super.createQuery(hql2).setInteger("parentLft", parentLft)

.executeUpdate();

System.out.println(hql1+"| parentLft = "+parentLft);

System.out.println(hql2+"| parentLft = "+parentLft);

// 再调整自己

hql ="select b.lft,b.rgt from "+ beanName +" b where b.id=:id";

position = (Object[])super.createQuery(hql).setLong("id",

tree.getId()).uniqueResult();

System.out.println(hql+"| id = "+tree.getId());

nodeLft = ((Number) position[0]).intValue();

nodeRgt = ((Number) position[1]).intValue();

intoffset = parentLft - nodeLft +1;

hql ="update "

+ beanName

+" b set b.lft=b.lft+:offset, b.rgt=b.rgt+:offset WHERE b.lft between :nodeLft and :nodeRgt";

if(!StringUtils.isBlank(tree.getTreeCondition())) {

hql +=" and ("+ tree.getTreeCondition() +")";

}

super.createQuery(hql).setParameter("offset", offset)

.setParameter("nodeLft", nodeLft).setParameter("nodeRgt",

nodeRgt).executeUpdate();

System.out.println(hql+"| offset = "+offset+" | nodelft = "+nodeLft+" | nodergt = "+ nodeRgt);

// 最后删除(清空位置)

hql1 ="update "+ beanName +" b set b.rgt = b.rgt - "+ span

+" WHERE b.rgt > :nodeRgt";

hql2 ="update "+ beanName +" b set b.lft = b.lft - "+ span

+" WHERE b.lft > :nodeRgt";

if(tree.getTreeCondition() !=null) {

hql1 +=" and ("+ tree.getTreeCondition() +")";

hql2 +=" and ("+ tree.getTreeCondition() +")";

}

super.createQuery(hql1).setParameter("nodeRgt", nodeRgt)

.executeUpdate();

super.createQuery(hql2).setParameter("nodeRgt", nodeRgt)

.executeUpdate();

System.out.println(hql1+"| nodeRgt = "+nodeRgt);

System.out.println(hql2+"| nodeRgt = "+nodeRgt);

}

}

public void updateParent(HibernateTree tree, HibernateTree preParent,

HibernateTree curParent) {

if (preParent != null && preParent != null

&& !preParent.equals(curParent)) {

String beanName = tree.getClass().getName();

// 获得节点位置

String hql = "select b.lft,b.rgt from " + beanName

+ " b where b.id=:id";

Object[] position = (Object[]) super.createQuery(hql).setLong(

"id", tree.getId()).uniqueResult();

System.out.println(hql+"| id = "+tree.getId());

int nodeLft = ((Number) position[0]).intValue();

int nodeRgt = ((Number) position[1]).intValue();

int span = nodeRgt - nodeLft + 1;

// 获得当前父节点左位置

hql = "select b.lft from " + beanName + " b where b.id=:id";

int parentLft = ((Number) super.createQuery(hql).setLong("id",

curParent.getId()).uniqueResult()).intValue();

System.out.println(hql+"| id = "+curParent.getId());

// 先空出位置

String hql1 = "update " + beanName + " b set b.rgt = b.rgt + "

+ span + " WHERE b.rgt > :parentLft";

String hql2 = "update " + beanName + " b set b.lft = b.lft + "

+ span + " WHERE b.lft > :parentLft";

if (!StringUtils.isBlank(tree.getTreeCondition())) {

hql1 += " and (" + tree.getTreeCondition() + ")";

hql2 += " and (" + tree.getTreeCondition() + ")";

}

super.createQuery(hql1).setInteger("parentLft", parentLft)

.executeUpdate();

super.createQuery(hql2).setInteger("parentLft", parentLft)

.executeUpdate();

System.out.println(hql1+"| parentLft = "+parentLft);

System.out.println(hql2+"| parentLft = "+parentLft);

// 再调整自己

hql = "select b.lft,b.rgt from " + beanName + " b where b.id=:id";

position = (Object[]) super.createQuery(hql).setLong("id",

tree.getId()).uniqueResult();

System.out.println(hql+"| id = "+tree.getId());

nodeLft = ((Number) position[0]).intValue();

nodeRgt = ((Number) position[1]).intValue();

int offset = parentLft - nodeLft + 1;

hql = "update "

+ beanName

+ " b set b.lft=b.lft+:offset, b.rgt=b.rgt+:offset WHERE b.lft between :nodeLft and :nodeRgt";

if (!StringUtils.isBlank(tree.getTreeCondition())) {

hql += " and (" + tree.getTreeCondition() + ")";

}

super.createQuery(hql).setParameter("offset", offset)

.setParameter("nodeLft", nodeLft).setParameter("nodeRgt",

nodeRgt).executeUpdate();

System.out.println(hql+"| offset = "+offset+" | nodelft = "+nodeLft+" | nodergt = "+ nodeRgt);

// 最后删除(清空位置)

hql1 = "update " + beanName + " b set b.rgt = b.rgt - " + span

+ " WHERE b.rgt > :nodeRgt";

hql2 = "update " + beanName + " b set b.lft = b.lft - " + span

+ " WHERE b.lft > :nodeRgt";

if (tree.getTreeCondition() != null) {

hql1 += " and (" + tree.getTreeCondition() + ")";

hql2 += " and (" + tree.getTreeCondition() + ")";

}

super.createQuery(hql1).setParameter("nodeRgt", nodeRgt)

.executeUpdate();

super.createQuery(hql2).setParameter("nodeRgt", nodeRgt)

.executeUpdate();

System.out.println(hql1+"| nodeRgt = "+nodeRgt);

System.out.println(hql2+"| nodeRgt = "+nodeRgt);

}

}

３.删除节点

删除节点也比较简单，具体步骤为：

A．查找要删除节点的lft值

B．将所有lft和rgt大于删除节点lft值的都-2

Java代码如下：

Java代码 icon_copy.gif

publicvoidonDelete(Object entity, Serializable id, Object[] state,

String[] propertyNames, Type[] types) {

if(entityinstanceofHibernateTree) {

HibernateTree tree = (HibernateTree) entity;

String beanName = tree.getClass().getName();

Session session = getSession();

FlushMode model = session.getFlushMode();

session.setFlushMode(FlushMode.MANUAL);

//查找要删除的节点的左值

String hql ="select b.lft from "+ beanName +" b where b.id=:id";

Integer myPosition = (Integer) session.createQuery(hql).setLong(

"id", tree.getId()).uniqueResult();

//将所有大于删除节点左值的rgt都-2

String hql1 ="update "+ beanName

+" b set b.rgt = b.rgt - 2 WHERE b.rgt > :myPosition";

//将所有大于删除节点左值的lft都-2

String hql2 ="update "+ beanName

+" b set b.lft = b.lft - 2 WHERE b.lft > :myPosition";

if(tree.getTreeCondition() !=null) {

hql1 +=" and ("+ tree.getTreeCondition() +")";

hql2 +=" and ("+ tree.getTreeCondition() +")";

}

session.createQuery(hql1).setInteger("myPosition", myPosition)

.executeUpdate();

session.createQuery(hql2).setInteger("myPosition", myPosition)

.executeUpdate();

session.setFlushMode(model);

}

}

public void onDelete(Object entity, Serializable id, Object[] state,

String[] propertyNames, Type[] types) {

if (entity instanceof HibernateTree) {

HibernateTree tree = (HibernateTree) entity;

String beanName = tree.getClass().getName();

Session session = getSession();

FlushMode model = session.getFlushMode();

session.setFlushMode(FlushMode.MANUAL);

//查找要删除的节点的左值

String hql = "select b.lft from " + beanName + " b where b.id=:id";

Integer myPosition = (Integer) session.createQuery(hql).setLong(

"id", tree.getId()).uniqueResult();

//将所有大于删除节点左值的rgt都-2

String hql1 = "update " + beanName

+ " b set b.rgt = b.rgt - 2 WHERE b.rgt > :myPosition";

//将所有大于删除节点左值的lft都-2

String hql2 = "update " + beanName

+ " b set b.lft = b.lft - 2 WHERE b.lft > :myPosition";

if (tree.getTreeCondition() != null) {

hql1 += " and (" + tree.getTreeCondition() + ")";

hql2 += " and (" + tree.getTreeCondition() + ")";

}

session.createQuery(hql1).setInteger("myPosition", myPosition)

.executeUpdate();

session.createQuery(hql2).setInteger("myPosition", myPosition)

.executeUpdate();

session.setFlushMode(model);

}

}

weixin_39728221
关注
java树形算法_java数据结构排序算法之树形选择排序详解
weixin_29358811的博客
02-12 662
本文实例讲述了java数据结构排序算法之树形选择排序。分享给大家供大家参考，具体如下：这里我们就来说说选择类排序之一的排序：树形选择排序在简单选择排序中，每次的比较都没有用到上次比较的结果，所以比较操作的时间复杂度是O(N^2)，想要降低比较的次数，则需要把比较过程中的大小关系保存下来。树形选择排序是对简单选择排序的改进。树形选择排序：又称锦标赛排序(Tournament Sort)，是一种按照锦...
java算法非常详细的树，图，存储结构
01-01
java算法，非常详细的树，图，存储结构
java中存储树结构
yeah_you_are的博客
03-06 1747
java中存储树结构 树是数据结构中的一种，是有限个节点组成的集合。那么在java中如何存储这种结构呢? 这里以二叉树为例，首先想到的方法就是定义节点类，代码如下： //节点类 public class Node<T> { //节点值 private T t; //左节点 private Node<T> leftNode; //右节点 private Node<T> rightNode; public Node
Java数据结构-树及树的存储结构
chiweihun1888的博客
07-24 628
树的定义：n（n>=0）个节点的有限集。 n=0时称为空树。 n!=0时为非空树，有且仅有一个特定的节点——根；n>1时，其它节点可以分为m（m>0）个互不相交的有限集T1~Tm，其中每一个集合本身又是一棵树，并且称为根的子树。 树的一些基本...
Java数据结构—树
Green_756的博客
09-05 3992
java、数据结构、树
java实现树形结构数据
qq_46239275的博客
11-30 7151
1、表结构字段：（id，name，partent_id - 父级id对应这id字段) 2、写好当前表的实体 3、扩展实体VO /** * entity 对应着表的实体 * 继承着对应的表实体 **/ @Data public class FwcEmpdeptVo extends entity{ /** * 子级节点 **/ private List<FwcEmpdeptVo> children = new ArrayList<>(); } 4、service实现树
基于JAVA建立树形结构的算法优化.pdf
07-02
在设计树形结构算法时，需要考虑如何高效地从原始数据中构建出所需的树形结构。算法设计的关键在于节点的查找和插入，尤其是如何高效地从上一级节点找到下一级的所有子节点。在树形结构中，每个节点可能包含多个子...
java数据结构排序算法之树形选择排序详解
08-30
在这个实现中，我们首先定义了一个数组tree来存储树形结构，然后我们构建了树形结构，并对记录进行比较和选择。最后，我们将选择的最小关键字组合成一个有序的序列。 树形选择排序的时间复杂度： 树形选择排序的...
使用递归算法结合数据库解析成Java树形结构的代码解析
08-29
使用递归算法结合数据库解析成Java树形结构的代码解析是指通过递归算法解析数据库中的树形结构数据，并将其转换为Java树形结构的过程。 首先，需要准备好表结构及对应的表数据。在这个示例中，我们创建了一个名为TB...
Java创建树形结构算法实例代码
08-31
总结起来，Java创建树形结构算法的核心在于使用数据结构（如List和Map）和适当的排序机制来构建层次关系。`MenuExt`类和`createTreeMenus()`方法的实现是这种思路的具体体现，它们能帮助开发者在JavaWeb应用中构建出...
java树形结构存储_树形结构数据存储方案的选择和java list转tree
weixin_33355665的博客
02-12 1184
树形结构数据存储方案Adjacency List：每一条记录存parent_idPath Enumerations：每一条记录存整个tree path经过的node枚举Nested Sets：每一条记录存 nleft 和 nrightClosure Table：维护一个表，所有的tree path作为记录进行保存。各种方法的常用操作代价见下图一般来说，数据量小，采用适合邻接表存储设计，简单灵活，而...
Java中树的存储结构实现
u012632105的博客
05-25 592
Java中树的存储结构实现
java 存储树_Java数据结构-树及树的存储结构
weixin_32288959的博客
02-18 734
树的定义：n(n>=0)个节点的有限集。n=0时称为空树。n!=0时为非空树，有且仅有一个特定的节点——根；n>1时，其它节点可以分为m(m>0)个互不相交的有限集T1~Tm，其中每一个集合本身又是一棵树，并且称为根的子树。树的一些基本术语：树的结点：由一个数据元素和若干个指向其子树的分支组成。结点的度：结点所拥有的子树的个数(即分支数)称为该结点的度。叶子结点：度为0的结点称为...
使用树形结构保存实体
brightloong的博客
10-09 1269
tree 阅读原文请访问我的博客BrightLoong's Blog 之前在项目需要实现一个功能——将xml文件映射成实体，然后对映射的实体进行逻辑处理，最后保存到数据库中；由于xml结构的数据是结构化的数据，所以需要保证保存的数据具有正确的主外键关联。如下所示，是一个需要保存到数据库的xml文件。当映射成对应的实体school和student...
java中的树_Java中树的存储结构实现示例代码
weixin_28710999的博客
02-12 224
一、树树与线性表、栈、队列等线性结构不同，树是一种非线性结构。一棵树只有一个根节点，如果一棵树有了多个根节点，那它已经不再是一棵树了，而是多棵树的集合，也被称为森林。二、树的父节点表示法树中除根节点之外每个节点都有一个父节点，为了记录树中节点与节点之间的父子关系，可以为每个节点增加一个parent域，用以记录该节点的父节点。package com.ietree.basic.datastructur...
数据结构——二叉树的存储结构（Java实现）
ZeroZiano博客
04-25 4230
二叉树的定义二叉树（Binary Tree）是n(n≥0)个结点的有限集合，该集合或者为空集，或者由一个根结点和两颗互不相交的，分别称为根结点的左子树和右子树的二叉树组成。二叉树的定义也采用了递归，听起来有些绕，如果了解了树的结构的话，二叉树也可以定义为：二叉树是每个结点最多只有两个分支的树结构。下列图中均为二叉树：              注意：二叉树是不存在度大于2的结点，不是只有两棵子树，...
重温数据结构：树 及 Java 实现
热门推荐
张拭心的博客 shixinzhang
11-17 3万+
读完本文你将了解到： 什么是树 树的相关术语 根节点、父亲节点、孩子节点、叶子节点如上所述。 节点的度 树的度 节点的层次 树的高度 树的深度 树的两种实现 数组表示： 链表表示的节点： 树的几种常见分类及使用场景 数据结构，指的是数据的存储形式，常见的有线性结构（数组、链表，队列、栈），还有非线性结构（树、图等）。 今天我们来学习下数据结构中的 树。 什么是...
java组织树_更好的形成树形组织结构图的方法
weixin_35767900的博客
02-24 1124
说明中的方法比较常规，思路还算比较清晰。但是缺点是对数据库层级有依赖，比如如果系统连的是MySQL数据库，那么要用到MySQL系统自带的FIND_IN_SET函数和自己设计的getChildList函数。如果系统连接的是Oracle数据库，Oracle没有FIND_IN_SET函数，按这个思路还要自己实现FIND_IN_SET函数，然后再实现一遍Oracle下的getChildList函数。有没有...
JAVA树形结构算法优化方案解析
7. 案例分析与实践：本资源可能包含实际案例分析，通过特定问题，如文件系统管理或搜索引擎索引构建，来展示如何应用优化后的树形结构算法解决实际问题。 8. 测试和验证：介绍了如何对优化后的树形结构算法进行测试...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值