java树形结构 算法

最新推荐文章于 2024-04-23 21:30:12 发布
最新推荐文章于 2024-04-23 21:30:12 发布
阅读量1.6k 收藏
点赞数 2
文章标签： java string integer object null session

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

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

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

 

Sql代码
  1. select  *  from  tableName  connect   by   prior  id=sj_parent_id start  with   id=1   
select * from tableName connect by prior id=sj_parent_id start with  id=1

 

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

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

 

Sql代码
  1. select  *  from  tableName  connect   by   prior  sj_parent_id =id start  with   id=1   
select * from tableName connect by prior sj_parent_id =id start with  id=1

 

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

 

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

 


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

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

<!--EndFragment-->

 

<!--EndFragment-->

Sql代码
  1. select  *  from  tb_subject s,tb_subject t  where  s.lft  between  t.lft  and  t.rgt  and  t.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 语句为：

<!--EndFragment-->

Sql代码
  1. 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   
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-->

Java代码
  1. public   boolean  onSave(Object entity, Serializable id, Object[] state,  
  2.             String[] propertyNames, Type[] types) {  
  3.         if  (entity  instanceof  HibernateTree) {  
  4.             HibernateTree tree = (HibernateTree) entity;  
  5.             Long parentId = tree.getParentId();  
  6.             String beanName = tree.getClass().getName();  
  7.             Session session = getSession();  
  8.             FlushMode model = session.getFlushMode();  
  9.             session.setFlushMode(FlushMode.MANUAL);  
  10.             Integer myPosition = new  Integer( 0 );  
  11.             //查找父节点的左值   
  12.             if  (parentId !=  null ) {  
  13.                 String hql = "select b.lft from "  + beanName  
  14.                         + " b where b.id=:pid" ;  
  15.                 myPosition = (Integer) session.createQuery(hql).setLong("pid" ,  
  16.                         parentId).uniqueResult();  
  17.             }  
  18.             //将树形结构中所有大于父节点左值的右节点+2   
  19.             String hql1 = "update "  + beanName  
  20.                     + " b set b.rgt = b.rgt + 2 WHERE b.rgt > :myPosition" ;  
  21.             //将树形结构中所有大于父节点左值的左节点+2   
  22.             String hql2 = "update "  + beanName  
  23.                     + " b set b.lft = b.lft + 2 WHERE b.lft > :myPosition" ;  
  24.             if  (!StringUtils.isBlank(tree.getTreeCondition())) {  
  25.                 hql1 += " and ("  + tree.getTreeCondition() +  ")" ;  
  26.                 hql2 += " and ("  + tree.getTreeCondition() +  ")" ;  
  27.             }  
  28.             session.createQuery(hql1).setInteger("myPosition" , myPosition)  
  29.                     .executeUpdate();  
  30.             session.createQuery(hql2).setInteger("myPosition" , myPosition)  
  31.                     .executeUpdate();  
  32.             session.setFlushMode(model);  
  33.             //定位自己的左值(父节点左值+1)和右值(父节点左值+2)   
  34.             for  ( int  i =  0 ; i < propertyNames.length; i++) {  
  35.                 if  (propertyNames[i].equals(HibernateTree.LFT)) {  
  36.                     state[i] = myPosition + 1 ;  
  37.                 }  
  38.                 if  (propertyNames[i].equals(HibernateTree.RGT)) {  
  39.                     state[i] = myPosition + 2 ;  
  40.                 }  
  41.   
  42.             }  
  43.             return   true ;  
  44.         }  
  45.         return   false ;  
  46.     }   
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

　J ava代码如下：

<!--EndFragment-->

Java代码
  1. public   void  updateParent(HibernateTree tree, HibernateTree preParent,  
  2.             HibernateTree curParent) {  
  3.         if  (preParent !=  null  && preParent !=  null   
  4.                 && !preParent.equals(curParent)) {  
  5.             String beanName = tree.getClass().getName();  
  6.             // 获得节点位置   
  7.             String hql = "select b.lft,b.rgt from "  + beanName  
  8.                     + " b where b.id=:id" ;  
  9.             Object[] position = (Object[]) super .createQuery(hql).setLong(  
  10.                     "id" , tree.getId()).uniqueResult();  
  11.             System.out.println(hql+"| id = " +tree.getId());   
  12.             int  nodeLft = ((Number) position[ 0 ]).intValue();  
  13.             int  nodeRgt = ((Number) position[ 1 ]).intValue();  
  14.             int  span = nodeRgt - nodeLft +  1 ;  
  15.             // 获得当前父节点左位置   
  16.             hql = "select b.lft from "  + beanName +  " b where b.id=:id" ;  
  17.             int  parentLft = ((Number)  super .createQuery(hql).setLong( "id" ,  
  18.                     curParent.getId()).uniqueResult()).intValue();  
  19.   
  20.             System.out.println(hql+"| id = " +curParent.getId());  
  21.             // 先空出位置   
  22.             String hql1 = "update "  + beanName +  " b set b.rgt = b.rgt + "   
  23.                     + span + " WHERE b.rgt > :parentLft" ;  
  24.             String hql2 = "update "  + beanName +  " b set b.lft = b.lft + "   
  25.                     + span + " WHERE b.lft > :parentLft" ;  
  26.             if  (!StringUtils.isBlank(tree.getTreeCondition())) {  
  27.                 hql1 += " and ("  + tree.getTreeCondition() +  ")" ;  
  28.                 hql2 += " and ("  + tree.getTreeCondition() +  ")" ;  
  29.             }  
  30.             super .createQuery(hql1).setInteger( "parentLft" , parentLft)  
  31.                     .executeUpdate();  
  32.             super .createQuery(hql2).setInteger( "parentLft" , parentLft)  
  33.                     .executeUpdate();  
  34.   
  35.             System.out.println(hql1+"| parentLft = " +parentLft);  
  36.             System.out.println(hql2+"| parentLft = " +parentLft);  
  37.               
  38.             // 再调整自己   
  39.             hql = "select b.lft,b.rgt from "  + beanName +  " b where b.id=:id" ;  
  40.             position = (Object[]) super .createQuery(hql).setLong( "id" ,  
  41.                     tree.getId()).uniqueResult();  
  42.             System.out.println(hql+"| id = " +tree.getId());  
  43.             nodeLft = ((Number) position[0 ]).intValue();  
  44.             nodeRgt = ((Number) position[1 ]).intValue();  
  45.             int  offset = parentLft - nodeLft +  1 ;  
  46.             hql = "update "   
  47.                     + beanName  
  48.                     + " b set b.lft=b.lft+:offset, b.rgt=b.rgt+:offset WHERE b.lft between :nodeLft and :nodeRgt" ;  
  49.             if  (!StringUtils.isBlank(tree.getTreeCondition())) {  
  50.                 hql += " and ("  + tree.getTreeCondition() +  ")" ;  
  51.             }  
  52.             super .createQuery(hql).setParameter( "offset" , offset)  
  53.                     .setParameter("nodeLft" , nodeLft).setParameter( "nodeRgt" ,  
  54.                             nodeRgt).executeUpdate();  
  55.             System.out.println(hql+"| offset = " +offset+ " | nodelft = " +nodeLft+ " | nodergt = " + nodeRgt);  
  56.             // 最后删除（清空位置）   
  57.             hql1 = "update "  + beanName +  " b set b.rgt = b.rgt - "  + span  
  58.                     + " WHERE b.rgt > :nodeRgt" ;  
  59.             hql2 = "update "  + beanName +  " b set b.lft = b.lft - "  + span  
  60.                     + " WHERE b.lft > :nodeRgt" ;  
  61.             if  (tree.getTreeCondition() !=  null ) {  
  62.                 hql1 += " and ("  + tree.getTreeCondition() +  ")" ;  
  63.                 hql2 += " and ("  + tree.getTreeCondition() +  ")" ;  
  64.             }  
  65.             super .createQuery(hql1).setParameter( "nodeRgt" , nodeRgt)  
  66.                     .executeUpdate();  
  67.             super .createQuery(hql2).setParameter( "nodeRgt" , nodeRgt)  
  68.                     .executeUpdate();  
  69.             System.out.println(hql1+"| nodeRgt = " +nodeRgt);  
  70.             System.out.println(hql2+"| nodeRgt = " +nodeRgt);  
  71.               
  72.         }  
  73.     }   
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

　J ava代码如下：

<!--EndFragment-->

 

 

 

<!--EndFragment-->
Java代码
  1. public   void  onDelete(Object entity, Serializable id, Object[] state,  
  2.             String[] propertyNames, Type[] types) {  
  3.         if  (entity  instanceof  HibernateTree) {  
  4.             HibernateTree tree = (HibernateTree) entity;  
  5.             String beanName = tree.getClass().getName();  
  6.             Session session = getSession();  
  7.             FlushMode model = session.getFlushMode();  
  8.             session.setFlushMode(FlushMode.MANUAL);  
  9.         //查找要删除的节点的左值   
  10.             String hql = "select b.lft from "  + beanName +  " b where b.id=:id" ;  
  11.             Integer myPosition = (Integer) session.createQuery(hql).setLong(  
  12.                     "id" , tree.getId()).uniqueResult();  
  13. //将所有大于删除节点左值的rgt都-2   
  14.             String hql1 = "update "  + beanName  
  15.                     + " b set b.rgt = b.rgt - 2 WHERE b.rgt > :myPosition" ;  
  16. //将所有大于删除节点左值的lft都-2   
  17.             String hql2 = "update "  + beanName  
  18.                     + " b set b.lft = b.lft - 2 WHERE b.lft > :myPosition" ;  
  19.             if  (tree.getTreeCondition() !=  null ) {  
  20.                 hql1 += " and ("  + tree.getTreeCondition() +  ")" ;  
  21.                 hql2 += " and ("  + tree.getTreeCondition() +  ")" ;  
  22.             }  
  23.             session.createQuery(hql1).setInteger("myPosition" , myPosition)  
  24.                     .executeUpdate();  
  25.             session.createQuery(hql2).setInteger("myPosition" , myPosition)  
  26.                     .executeUpdate();  
  27.             session.setFlushMode(model);  
  28.         }  
  29.     }   
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-->

 

 

 

http://www.javaeye.com/topic/602979

zengbo0710
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
如何使用Java构造层级结构的树形数据
12-25 7150
层级结构的数据在日常工作中是很常见的，例如：地市层级数据，机构层级数据，单位层级数据等等。 这周在工作中，我就遇到了需要处理层级结构的数据，功能需求很简单：前端有个查询页面，需要根据地市查询相应的数据，并且地市是按照层级展示的，选择对应的地市，需要将当前地市及其所有下级地市数据展现出来。这篇文章主要记录一下如何使用Java构造一个层级结构的树形数据。 一、实现思路 构造层级数据，首先需要确保处理的数据是满足层级关系的，即：可以通过编号能够找到对应的上级编号，如果是最顶层数据，则顶层编号可以为空或者为指
Java 树构建最快算法
weixin_45353700的博客
09-13 2394
普通树构建算法都是通过递归遍历所有节点来找出当前节点的子节点实现的，计算次数成指数级增长，数据量达到上万条效率就已经不能满足需求了，可以考虑利用LinkedHashMap来保存所有节点，查找过程用LinkedHashMap来实现，经过实践，运算次数从2亿次减少到了2万7千多次，耗时从5秒减少到了450ms左右，效率提升了10倍有余。项目中经常会用到树构建，比如地区树型数据构建，测试中一个省到街道级别的地区数据，共有13828条，普通的递归构建树算法计算次数接近2亿次，
Java 【数据结构】 二叉树（Binary_Tree）【神装】
最新发布
2302_79806056的博客
04-23 1571
首先，我意识到了数据结构在编程中的关键性，二叉树作为其中的重要一环，对算法设计和问题解决都有着深远的影响。深入理解二叉树的基本概念，如节点、根节点、子节点等，为我理解二叉树结构和算法打下了坚实的基础。掌握了常见的操作和遍历算法，如插入节点、删除节点以及深度优先遍历和广度优先遍历，这些都是对树形结构理解和应用至关重要的。
通过Java构建树形结构
weixin_60382322的博客
10-26 3599
我这里当节点的parentId = ‘-1’ 那么这个节点就是根节点。
java生成树形结构的算法
m0_49830850的博客
06-13 243
快速把数据表生成前端需要的树形结构
【数据结构与算法】数据结构与算法之树Tree（Java版）
fearless的博客
02-24 1669
文章内容一、树的基本概念1. 定义2. 基本术语3. 存储结构二、二叉树1. 定义2. 主要性质 如果觉得有帮助，麻烦动动手指点赞加关注???????????? 非常感谢！！！ 有想看源码的小伙伴请移步这里????https://gitee.com/fearless123/demo/tree/master/src/main/java/com/ma 一、树的基本概念 1. 定义 将具有一对多关系的集合中的元素按照上图中的逻辑结构存储，整个存储形状从逻辑结构上看就像现实生活中一颗倒着生长的树，毕竟形象生动，所
基于JAVA建立树形结构的算法优化.pdf
07-02
基于JAVA建立树形结构的算法优化.pdf
java数据结构排序算法之树形选择排序详解
08-30
树形选择排序的算法过程可以分为三步：构建树形结构、比较和选择、排序输出。 首先，我们构建一个树形结构，每个叶子结点代表一个记录，非叶子结点代表一个比较结果。然后，我们从叶子结点开始，逐步比较和选择最小...
使用递归算法结合数据库解析成Java树形结构的代码解析
08-29
使用递归算法结合数据库解析成Java树形结构的代码解析是指通过递归算法解析数据库中的树形结构数据，并将其转换为Java树形结构的过程。 首先，需要准备好表结构及对应的表数据。在这个示例中，我们创建了一个名为TB...
Java创建树形结构算法实例代码
08-31
总结起来，Java创建树形结构算法的核心在于使用数据结构（如List和Map）和适当的排序机制来构建层次关系。`MenuExt`类和`createTreeMenus()`方法的实现是这种思路的具体体现，它们能帮助开发者在JavaWeb应用中构建出...
Java递归算法构造JSON树形结构
10-20
Java 递归算法构造 JSON 树形结构 Java 递归算法构造 JSON 树形结构是指通过 Java 语言使用递归算法将数据库中的菜单表构建成树形的 JSON 格式发送给第三方。这种方法可以将复杂的树形结构数据转换成易于理解和处理...
二叉树的遍历和周游的算法
05-08
二叉树的遍历和周游是一个很基本很基础，但是是一个很重要的问题，这个文档将帮助你理解的更好
树的总结（算法）
justsolow的博客
05-19 1538
树的总结（算法） 总的来说树需要掌握的由一下几点： 1、树的遍历方式：前序（根左右），中序（左根右，二叉搜索树中序遍历必有序），后序（左右根），层序（一个列表，多个列表，之字形） 2、树的递归 3、树的迭代（利用栈来实现） 4、树的创建（列表或者是字典） 5、树的动态规划（动态规划里面再讲） 下面就具体的一些题目来说一下。 首先放一下树递归的GIF图（来自leetcode的一个大佬制作的） 上面这个图是递归的基础，必须牢记。 我自己总结了一下相应的树的算法。仅供参考。 代码都是用python3写的，基本上
java数据结构与算法（八）——树
MY_NEW_LIFE的博客
05-13 106
树
用递归算法得到Java的树形结构
热门推荐
山鬼谣的专栏
07-08 1万+
要求：得到无限分类的菜单栏。并且告诉你任何一个节点，都能得到整个菜单。数据库是mongodb。没有贴全部，只贴部分。 首先一个整体思路是： 1、要有一个能通过父类id得到全部子类id的集合。 2、遍历这些子类集合来把它们的关系关联起来。代码部分： 建立数据库的查询：DBCollection collection = GGMongoOperator.getGGBusinessCollectio
JAVA 算法——树
hqiangtai的博客
03-12 511
1、二叉搜索树    二叉搜索树需满足以下四个条件：若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值；若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值；任意节点的左、右子树也分别为二叉查找树；没有键值相等的节点。2、什么是伸展树（Splay Tree） 假设想要对一个二叉查找树执行一系列的查找操作。为了使整个查找时间更小，被查频率高的那些条目就应当经常处于靠近树...
【java基础 3】树形结构数据呈现的递归算法实现
该怎么解释？我懒得解释
08-27 1万+
一、基本概况 在我的项目中，常常会用到树形结构的数据，最为明显的就是左边菜单栏，类似于window folder一样的东西。 而我之前一直是借助前端封装好的ZTree等工具实现展示，而后台则通常使用递归进行数据的查找。通常，我们在设计数据库表的时候，一般会使用三个字段：id，name，pid。如下图所示： 二、代码实现 首先是建立实体类： private Str
java实现树_数据结构与算法
Aye
04-04 1083
1.二叉树：n个具有相同类型的数据元素的有限集合；左子树-根-右子树；有序。2.二叉树的度：最大的节点度数3.满二叉树：所有分支节点均存在左子树和右子树，且所有叶子节点均在同一层上4.完全二叉树：存在的节点与满二叉树的节点编号相同，叶子节点只存在最后一层及倒数第二层5.非空二叉树的i层最多有 2【i-1】个节点6.深度为k的二叉树至多有2【k】-1个节点7.给出完全二叉树的节点数则完全二叉树的深度...
Java创建树形结构算法实例
AlbenXie的博客
09-04 1244
在JavaWeb的相关开发中经常会涉及到多级菜单的展示，为了方便菜单的管理需要使用数据库进行支持，本例采用相关算法讲数据库中的条形记录进行相关组装和排序讲菜单组装成树形结构。 首先是需要的JavaBean 1 2 3 import java.io.Serializable; 4 import java.util.ArrayList; 5 import java
java树形结构过滤
11-23
树形结构过滤是指基于树形结构的数据进行筛选和过滤，只显示符合特定条件的数据。 在Java中，实现树形结构过滤可以借助于递归算法和条件判断来实现。首先，需要定义树形数据结构的节点类，每个节点包含自身的信息以及子节点的引用。然后，使用递归的方法遍历整个树形结构，对每个节点进行条件判断，将符合条件的节点添加到结果集合中。 在进行树形结构过滤时，可以根据不同的条件进行筛选，比如节点的属性值或者节点的深度等。通过条件判断，将符合条件的节点找出来，并添加到结果集合中。 在代码实现上，可以通过编写一个递归方法，该方法接收当前节点和过滤条件作为参数，在方法内部对当前节点进行条件判断，如果符合条件，则将其添加到结果集合中，并继续递归遍历其子节点。通过递归方法的不断调用，可以将整个树形结构进行过滤。 总之，通过在Java中编写递归算法和条件判断，可以实现树形结构的过滤功能，从而实现对树形数据的筛选和过滤操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值