java树形结构 算法

最新推荐文章于 2024-10-13 21:30:16 发布
最新推荐文章于 2024-10-13 21:30:16 发布
阅读量260 收藏
点赞数
分类专栏： java 文章标签： 算法 数据结构 Java SQL C#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhanglun1225/article/details/83558863
版权

最近看到一个有意思的树形结构，为每个节点添加了lft和rgt两个属性。这样查找该节点的子节点、查找该节点所有父节点，就不用去递归查询，只需要用between、and语句就可以实现。下面以创建一个栏目树为例，以下是我的理解。

　　一般来讲，我们创建栏目树的时候，大多只需要一个外键parentid来区分该节点属于哪个父节点。数据库的设计如下图：
这样一来，

1.查找该节点的所有子节点，则需要采用sql的递归语句：

 

select * from tableName connect by prior id=sj_parent_id start with  id=1

 

 (oracle 写法，mysql目前不支持，如果mysql想查找树形，可以利用存储过程).

2.查找该节点的父节点的sql递归语句：

 

select * from tableName connect by prior sj_parent_id =id start with  id=1

 

　如果数据量过大或者层次太多，那么这样操作是会影响性能的。

 

　　“任何树形结构都可以用二叉树来表示”。其实我们创建的栏目树就是一个简型的二叉树。根据数据结构里面二叉树的遍历，再稍微修改下，将数据库设计如下图所示：

 


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

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

<!--EndFragment-->

 

<!--EndFragment-->

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

 

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

<!--EndFragment-->

select s.* from tb_subject s,tb_subject t where s.lft<t.lft and (s.rgt-s.lft)>1 and s.rgt>t.rgt and t.id=1

 

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

<!--EndFragment-->

　1. 新增节点

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

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

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

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

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

<!--EndFragment-->

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代码如下：

<!--EndFragment-->

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代码如下：

<!--EndFragment-->

 

 

<!--EndFragment--> 
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);
		}
	}

 
 

 

 

 

<!--EndFragment-->

 

 

<!--EndFragment-->

 

<!--EndFragment-->

 

<!--EndFragment-->

 

 

<!--EndFragment-->

 

 

 

 

<!--EndFragment-->
zhanglun1225
关注
专栏目录
Java 实现树形结构
DriverKing
09-04 1万+
树形结构可以清楚地呈现数据的从属关系，在数据库中我们可以用自关联来保存这样的关系。但是在取出数据的时候，如果采用以往的手段，免不了要进行递归操作。递归在理论上是可以解决树形结构的问题，但是如果数据量够大，目录层次够深，我们递归出层次关系是比较消耗资源的。我们可以从数据结构入手，树
java 树算法_Java数据结构与算法-树
weixin_42423852的博客
02-12 453
(摘录加总结------)一、树的概念(1)树是一种非线性的数据结构，是由n(n>=1)个有限节点组成的有层次关系的集合，在树中有许多节点，每一个节点最多只有一个父节点，并且可能会有0个或者更多个子节点，没有父节点的那个称为根节点，除了根节点外，每个节点又可分为多个不相交的子树。(2)树的相关概念术语：1)节点树中每个元素都叫节点2)根节点或树根树顶端的节点称之为根节点，也叫树根3)子树除根...
java树形结构
01-14
$(function(){ $.fn.extend({ SimpleTree:function(options){ //初始化参数 var option = $.extend({ click:function(a){ } },options); option.tree=this; /* 在参数对象中添加对当前菜单树的引用，以便在对象中使用该菜单树 */ option._init=function(){ /* * 初始化菜单展开状态，以及分叉节点的样式 */ this.tree.find("ul ul").hide(); /* 隐藏所有子级菜单 */ this.tree.find("ul ul").prev("li").removeClass("open"); /* 移除所有子级菜单父节点的 open 样式 */ this.tree.find("ul ul[show='true']").show(); /* 显示 show 属性为 true 的子级菜单 */ this.tree.find("ul ul[show='true']").prev("li").addClass("open"); /* 添加 show 属性为 true 的子级菜单父节点的 open 样式 */ }/* option._init() End */ /* 设置所有超链接不响应单击事件 */ this.find("a").click(function(){ $(this).parent("li").click(); return false; }); /* 菜单项 接受单击 */ this.find("li").click(function(){ /* * 当单击菜单项 * 1.触发用户自定义的单击事件，将该 标签中的第一个超链接做为参数传递过去 * 2.修改当前菜单项所属的子菜单的显示状态（如果等于 true 将其设置为 false，否则将其设置为 true） * 3.重新初始化菜单 */ option.click($(this).find("a")[0]); /* 触发单击 */ /* * 如果当前节点下面包含子菜单，并且其 show 属性的值为 true，则修改其 show 属性为 false * 否则修改其 show 属性为 true */ /* if($(this).next("ul").attr("show")=="true"){ $(this).next("ul").attr("show","false"); }else{ $(this).next("ul").attr("show","true"); }*/ /* 初始化菜单 */ option._init(); }); /* 设置所有父节点样式 */ this.find("ul").prev("li").addClass("folder"); /* 设置节点“是否包含子节点”属性 */ this.find("li").find("a").attr("hasChild",false); this.find("ul").prev("li").find("a").attr("hasChild",true); /* 初始化菜单 */ option._init(); }/* SimpleTree Function End */ }); });
Java后端递归构建树形结构
彼岸尚有荣光在，应不断记录总结！！！
01-12 9533
记录：在Java后台利用递归思路进行构建树形结构数据，返回给前端，能以下拉菜单等形式进行展示。 简明：为了简化代码，引入Lombok的Jar包，可省略实体类set()、get()方法。 <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> ...
【Java数据结构】二叉树
最新发布
2401_83227065的博客
10-13 1051
1.2.3.4.
Java 树结构的算法
kejingli963的专栏
04-29 1630
Java 树结构的算法 基本概念 定义 **树（Tree）**是n（n>=0)个节点的有限集。n=0时称为空树。在任意一颗非空树中：   （1）有且仅有一个特定的称为根（Root）的节点；   （2）当n>1时，其余节点可分为m(m>0)个互不相交的有限集T1、T2、…、Tn，其中每一个集合本身又是一棵树，并且称为根的子树。 此外，树的定义还需要强调以下两点：   （3）n&gt...
基于JAVA建立树形结构的算法优化.pdf
07-02
在设计树形结构算法时，需要考虑如何高效地从原始数据中构建出所需的树形结构。算法设计的关键在于节点的查找和插入，尤其是如何高效地从上一级节点找到下一级的所有子节点。在树形结构中，每个节点可能包含多个子...
java数据结构排序算法之树形选择排序详解
08-30
树形选择排序的算法过程可以分为三步：构建树形结构、比较和选择、排序输出。 首先，我们构建一个树形结构，每个叶子结点代表一个记录，非叶子结点代表一个比较结果。然后，我们从叶子结点开始，逐步比较和选择最小...
Java创建树形结构算法实例代码
08-31
总结起来，Java创建树形结构算法的核心在于使用数据结构（如List和Map）和适当的排序机制来构建层次关系。`MenuExt`类和`createTreeMenus()`方法的实现是这种思路的具体体现，它们能帮助开发者在JavaWeb应用中构建出...
使用递归算法结合数据库解析成Java树形结构的代码解析
08-29
使用递归算法结合数据库解析成Java树形结构的代码解析是指通过递归算法解析数据库中的树形结构数据，并将其转换为Java树形结构的过程。 首先，需要准备好表结构及对应的表数据。在这个示例中，我们创建了一个名为TB...
树形结构设计总结java demo
03-04
在实际应用中，树形结构常用于实现文件系统、数据库索引、图算法（如A*寻路）、表达式解析、编译器语法树等。例如，在设计一个组织结构管理系统时，每个节点可以代表一个员工，其子节点则表示其下属，这样就形成了一...
Java递归算法构造JSON树形结构
10-20
Java递归算法构造JSON树形结构，Java递归算法构造JSON树形结构Java递归算法构造JSON树形结构
java生成树形结构的算法
m0_49830850的博客
06-13 269
快速把数据表生成前端需要的树形结构
树形结构——JAVA实现
码说芯语的博客
04-26 4808
一文掌握二叉树的结构及写法
Java 高效构建树形结构
qq_41902662的博客
11-22 5204
Java高效构建树
Java树形结构
Monkey_4
03-20 217
Java 树形结构
【Java 树形结构】
在这个充满危险的乱世之中，只有学会烤鸡才能顽强的活下去。
12-02 1353
基本思路 在开发的时候我们会遇到树状的结构，例如 部门、菜单等信息。 代码 我们先进行数据库中的设计 最重要的是有id和parent_id值，这样部门就可以进行关联了。 实体信息 @Data public class Department implements Serializable { private Integer id; private String name; private String nameEn; private Integer parentId; @TableFie
JAVA树形结构
huang404的专栏
06-27 3654
­//分类显示数据库里的内容­package mypkg; ­import java.awt.*; ­import java.awt.event.*; ­import javax.swing.*; ­import javax.swing.event.*; ­import java.util.*; ­import java.sql.*; ­import java.
JAVA树形结构算法优化方案解析
7. 案例分析与实践：本资源可能包含实际案例分析，通过特定问题，如文件系统管理或搜索引擎索引构建，来展示如何应用优化后的树形结构算法解决实际问题。 8. 测试和验证：介绍了如何对优化后的树形结构算法进行测试...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值