在数据库中存储树状结构

于 2023-10-29 11:04:14 发布
阅读量194 收藏 1
点赞数
文章标签： 数据库 oracle
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33888850/article/details/134100860
版权

问题

  • 实际开发中很多地方都需要存储树状结构，例如组织架构中需要用树状结构来表示公司员工之间的层级关系、电商网站中用树状结构来组织商品分类、论坛帖子或者评论中可以通过回复来构成树状结构。
  • 假设现在要存储一下公司的人员结构，大概层次如下
  • 怎么存储这个结构？并且要获取以下信息
    1. 查询小天的直接上司；
    2. 查询老宋管理下的直属员工；
    3. 查询小天的所有上司；
    4. 查询老王管理的所有员工。

方案一 Adjacency List（存储父节点）

数据库存储结构

-- ----------------------------
-- Table structure for employees
-- ----------------------------
DROP TABLE IF EXISTS `employees`;
CREATE TABLE `employees`  (
  `eid` int(11) NOT NULL COMMENT '主键ID',
  `ename` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '姓名',
  `position` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '位置',
  `parent_id` int(11) NULL DEFAULT NULL COMMENT '上级ID',
  PRIMARY KEY (`eid`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of employees
-- ----------------------------
INSERT INTO `employees` VALUES (1, '老王', '高管', 0);
INSERT INTO `employees` VALUES (2, '老宋', '产品部主管', 1);
INSERT INTO `employees` VALUES (3, '老牛', '技术部主管', 1);
INSERT INTO `employees` VALUES (4, '小吴', '产品A组长', 2);
INSERT INTO `employees` VALUES (5, '小李', '产品B组长', 2);
INSERT INTO `employees` VALUES (6, '小欢', '产品经理', 3);
INSERT INTO `employees` VALUES (7, '小小', '产品经理', 3);
INSERT INTO `employees` VALUES (8, '小天', '产品部员工', 4);
INSERT INTO `employees` VALUES (9, '小里', '产品部员工', 4);
INSERT INTO `employees` VALUES (10, '小黑', '产品部员工', 5);
INSERT INTO `employees` VALUES (11, '小胡', '产品部员工', 5);
INSERT INTO `employees` VALUES (12, '小丽', '技术部员工', 6);
INSERT INTO `employees` VALUES (13, '小蓝', '技术部员工', 6);
INSERT INTO `employees` VALUES (14, '小黄', '技术部员工', 7);
INSERT INTO `employees` VALUES (15, '小真', '技术部员工', 7);
eidenamepositionparent_id
1老王高管0
2老宋产品部主管1
3老牛技术部主管1
4小吴产品A组长2
5小李产品B组长2
6小欢产品经理3
7小小产品经理3
8小天产品部员工4
9小里产品部员工4
10小黑产品部员工5
11小胡产品部员工5
12小丽技术部员工6
13小蓝技术部员工6
14小黄技术部员工7
15小真技术部员工7

SQL示例

添加节点
  • 例如我要在小吴下添加一个员工
INSERT INTO employees(eid, ename, position, parent_id) 
VALUES(16, '小魏', '产品部员工', 4);
查询小天的直接上司
  • 方式一
SELECT e1.eid, e1.ename
FROM employees e1, employees e2
WHERE e1.eid = e2.parent_id
AND e2.ename = '小天'
  • 方式二
SELECT eid, ename
FROM employees
WHERE eid = (SELECT parent_id FROM employees WHERE ename = '小天')
  • 虽然上面两种方式都可以查询，但是推荐使用方式一来进行查询。因为方式二使用了子查询，每次运行外部查询时，都需要重新计算子查询，如果子查询中返回了大量的数据，会导致查询效率低下，绝大多数情况下，使用方式一的查询效率会更高。
查询老宋的直属员工
  • 这次我就不写子查询的方式了
SELECT e2.eid, e2.ename 
FROM employees e1, employees e2
WHERE e2.parent_id = e1.eid
AND e1.ename = '老宋'
查询小天的所有上司
  • 在MySQL8.0以后的版本，使用递归CTE可以轻松实现
WITH RECURSIVE Leader AS (
	SELECT eid, ename, position, parent_id 
	FROM employees
	WHERE ename = '小天'
	UNION ALL 
	SELECT e.eid, e.ename, e.position, e.parent_id 
	FROM employees e
	INNER JOIN Leader l
	ON e.eid = l.parent_id
)

SELECT eid, ename, position FROM Leader
  • 但是MySQL8.0之前没有CTE，只能写个函数，用循环进行循环查询，先查直接上司，再查直接上司的直接上司，实现起来很麻烦，并且返回的结果也不能是一张表
查询老王的所有员工
  • 这里还是使用递归CTE查询
WITH RECURSIVE Emp AS (
	SELECT eid, ename, position, parent_id 
	FROM employees
	WHERE ename = '老王'
	UNION ALL
	SELECT e.eid, e.ename, e.position, e.parent_id 
	FROM employees e
	INNER JOIN Emp emp 
	ON e.parent_id = emp.eid
)

SELECT eid, ename, position FROM Emp

方案二 Path Enumeration（存储路径）

  • Path Enumeration 路径枚举法，存储根节点到每个子节点的路径

数据库存储结构

-- ----------------------------
-- Table structure for employees2
-- ----------------------------
DROP TABLE IF EXISTS `employees2`;
CREATE TABLE `employees2`  (
  `eid` int(11) NOT NULL COMMENT '主键ID',
  `ename` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '姓名',
  `position` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '位置',
  `path` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '所在路径',
  PRIMARY KEY (`eid`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of employees2
-- ----------------------------
INSERT INTO `employees2` VALUES (1, '老王', '高管', '/1');
INSERT INTO `employees2` VALUES (2, '老宋', '产品部主管', '/1/2');
INSERT INTO `employees2` VALUES (3, '老牛', '技术部主管', '/1/3');
INSERT INTO `employees2` VALUES (4, '小吴', '产品A组长', '/1/2/4');
INSERT INTO `employees2` VALUES (5, '小李', '产品B组长', '/1/2/5');
INSERT INTO `employees2` VALUES (6, '小欢', '产品经理', '/1/3/6');
INSERT INTO `employees2` VALUES (7, '小小', '产品经理', '/1/3/7');
INSERT INTO `employees2` VALUES (8, '小天', '产品部员工', '/1/2/4/8');
INSERT INTO `employees2` VALUES (9, '小里', '产品部员工', '/1/2/4/9');
INSERT INTO `employees2` VALUES (10, '小黑', '产品部员工', '/1/2/5/10');
INSERT INTO `employees2` VALUES (11, '小胡', '产品部员工', '/1/2/5/11');
INSERT INTO `employees2` VALUES (12, '小丽', '技术部员工', '/1/3/6/12');
INSERT INTO `employees2` VALUES (13, '小蓝', '技术部员工', '/1/3/6/13');
INSERT INTO `employees2` VALUES (14, '小黄', '技术部员工', '/1/3/7/14');
INSERT INTO `employees2` VALUES (15, '小真', '技术部员工', '/1/3/7/15');
eidenamepositionparent_id
1老王高管/1
2老宋产品部主管/1/2
3老牛技术部主管/1/3
4小吴产品A组长/1/2/4
5小李产品B组长/1/2/5
6小欢产品经理/1/3/6
7小小产品经理/1/3/7
8小天产品部员工/1/2/4/8
9小里产品部员工/1/2/4/9
10小黑产品部员工/1/2/5/10
11小胡产品部员工/1/2/5/11
12小丽技术部员工/1/3/6/12
13小蓝技术部员工/1/3/6/13
14小黄技术部员工/1/3/7/14
15小真技术部员工/1/3/7/15
16小魏产品部员工/1/2/4/16

SQL示例

添加节点
  • 依旧是在小吴节点插入一个下属员工
-- 1. 插入下属员工小魏，eid为16，查询父级节点path，拼接小魏的path
INSERT INTO `employees2` (`eid`, `ename`, `position`, `path`)
SELECT 16 AS eid, '小魏' AS ename, '产品部员工' AS position, CONCAT(path, '/16') AS path
FROM `employees2`
WHERE ename = '小吴';
查询小天的直接上司
  • 在上一个解决方案中能轻易做到的事情，在这个方案中却有些麻烦了，因为我们需要对path字段做处理，去掉/ + 自身id 之后才是上司path的值，例如小天的path是/1/2/4/8，小天的eid是8，那么上司id就需要去掉/8，为/1/2/4
SELECT e1.eid,	e1.ename,	e1.position 
FROM employees2 e1,	employees2 e2 
WHERE	e2.ename = '小天' 
AND e1.path = REPLACE (e2.path,	CONCAT( '/', e2.eid ), '')
查询老宋的直属员工
  • 这里注意是查询直属员工，而不是所有员工，所以不能用LIKE来模糊匹配，而是需要使用正则来匹配单个层级
SELECT e1.eid, e1.ename, e1.position
FROM employees2 e1, employees2 e2
WHERE e2.ename = '老宋'
AND e1.path REGEXP CONCAT(e2.path, '/[0-9]{1,}$')
  • 但是如果想使用LIKE做模糊匹配也不是不行，可以增加一个level字段，用于表示层级。
    • 例如老王的level是1，老宋的level是2，老宋的直属员工的level就是3，以此类推，在构建查询语句的时候额外判定一下level就好了
SELECT e1.eid, e1.ename, e1.position
FROM employees2 e1, employees2 e2
WHERE e2.ename = '老宋'
AND e1.path LIKE CONCAT(e2.path, '/%')
AND e1.level = 3
查询小天的所有上司
  • 查询所有上司或者所有员工的时候，就可以使用LIKE做模糊匹配
SELECT e1.eid, e1.ename, e1.position
FROM employees2 e1, employees2 e2
WHERE e2.ename = '小天' 
AND e2.path LIKE CONCAT(e1.path, '/%')
查询老王的所有员工
SELECT e1.eid, e1.ename, e1.position
FROM employees2 e1, employees2 e2
WHERE e2.ename = '老王' 
AND e1.path LIKE CONCAT(e2.path, '/%')

方案三 Closure Table(存储关系表和深度)

  • 保存每个节点与其各个子节点的关系，也就是记录以其为根节点的全部子节点信息。

数据库存储结构

-- ----------------------------
-- Table structure for employees3
-- ----------------------------
DROP TABLE IF EXISTS `employees3`;
CREATE TABLE `employees3`  (
  `eid` int(11) NOT NULL COMMENT '主键ID',
  `ename` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '姓名',
  `position` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '位置',
  PRIMARY KEY (`eid`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of employees3
-- ----------------------------
INSERT INTO `employees3` VALUES (1, '老王', '高管');
INSERT INTO `employees3` VALUES (2, '老宋', '产品部主管');
INSERT INTO `employees3` VALUES (3, '老牛', '技术部主管');
INSERT INTO `employees3` VALUES (4, '小吴', '产品A组长');
INSERT INTO `employees3` VALUES (5, '小李', '产品B组长');
INSERT INTO `employees3` VALUES (6, '小欢', '产品经理');
INSERT INTO `employees3` VALUES (7, '小小', '产品经理');
INSERT INTO `employees3` VALUES (8, '小天', '产品部员工');
INSERT INTO `employees3` VALUES (9, '小里', '产品部员工');
INSERT INTO `employees3` VALUES (10, '小黑', '产品部员工');
INSERT INTO `employees3` VALUES (11, '小胡', '产品部员工');
INSERT INTO `employees3` VALUES (12, '小丽', '技术部员工');
INSERT INTO `employees3` VALUES (13, '小蓝', '技术部员工');
INSERT INTO `employees3` VALUES (14, '小黄', '技术部员工');
INSERT INTO `employees3` VALUES (15, '小真', '技术部员工');

-- ----------------------------
-- Table structure for emp_relations
-- ----------------------------
DROP TABLE IF EXISTS `emp_relations`;
CREATE TABLE `emp_relations`  (
  `root_id` int(11) NULL DEFAULT NULL COMMENT '根节点的eid',
  `depth` int(11) NULL DEFAULT NULL COMMENT '根节点到该节点的深度',
  `is_leaf` tinyint(1) NULL DEFAULT NULL COMMENT '该节点是否为叶子节点',
  `node_id` int(11) NULL DEFAULT NULL COMMENT '该节点的eid'
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of emp_relations
-- ----------------------------
INSERT INTO `emp_relations` VALUES (1, 0, 0, 1);
INSERT INTO `emp_relations` VALUES (1, 1, 0, 2);
INSERT INTO `emp_relations` VALUES (1, 1, 0, 3);
INSERT INTO `emp_relations` VALUES (1, 2, 0, 4);
INSERT INTO `emp_relations` VALUES (1, 2, 0, 5);
INSERT INTO `emp_relations` VALUES (1, 2, 0, 6);
INSERT INTO `emp_relations` VALUES (1, 2, 0, 7);
INSERT INTO `emp_relations` VALUES (1, 3, 1, 8);
INSERT INTO `emp_relations` VALUES (1, 3, 1, 9);
INSERT INTO `emp_relations` VALUES (1, 3, 1, 10);
INSERT INTO `emp_relations` VALUES (1, 3, 1, 11);
INSERT INTO `emp_relations` VALUES (1, 3, 1, 12);
INSERT INTO `emp_relations` VALUES (1, 3, 1, 13);
INSERT INTO `emp_relations` VALUES (1, 3, 1, 14);
INSERT INTO `emp_relations` VALUES (1, 3, 1, 15);
INSERT INTO `emp_relations` VALUES (2, 0, 0, 2);
INSERT INTO `emp_relations` VALUES (2, 1, 0, 4);
INSERT INTO `emp_relations` VALUES (2, 1, 0, 5);
INSERT INTO `emp_relations` VALUES (2, 2, 1, 8);
INSERT INTO `emp_relations` VALUES (2, 2, 1, 9);
INSERT INTO `emp_relations` VALUES (2, 2, 1, 0);
INSERT INTO `emp_relations` VALUES (2, 2, 1, 11);
INSERT INTO `emp_relations` VALUES (3, 0, 0, 3);
INSERT INTO `emp_relations` VALUES (3, 1, 0, 6);
INSERT INTO `emp_relations` VALUES (3, 1, 0, 7);
INSERT INTO `emp_relations` VALUES (3, 2, 1, 12);
INSERT INTO `emp_relations` VALUES (3, 2, 1, 13);
INSERT INTO `emp_relations` VALUES (3, 2, 1, 14);
INSERT INTO `emp_relations` VALUES (3, 2, 1, 15);
INSERT INTO `emp_relations` VALUES (4, 0, 0, 4);
INSERT INTO `emp_relations` VALUES (4, 1, 1, 8);
INSERT INTO `emp_relations` VALUES (4, 1, 1, 9);
INSERT INTO `emp_relations` VALUES (5, 0, 0, 5);
INSERT INTO `emp_relations` VALUES (5, 1, 1, 10);
INSERT INTO `emp_relations` VALUES (5, 1, 1, 11);
INSERT INTO `emp_relations` VALUES (5, 1, 1, 12);
  • 主表
eidenameposition
1老王高管
2老宋产品部主管
3老牛技术部主管
4小吴产品A组长
5小李产品B组长
6小欢产品经理
7小小产品经理
8小天产品部员工
9小里产品部员工
10小黑产品部员工
11小胡产品部员工
12小丽技术部员工
13小蓝技术部员工
14小黄技术部员工
15小真技术部员工
  • 闭包表
root_iddepthis_leafnode_id
1001
1102
1103
1204
1205
1206
1207
1318
1319
13110
13111
13112
13113
13114
13115
2002
2104
2105
2218
2219
2210
22111
3003
3106
3107
32112
32113
32114
32115
4004
4118
4119
5005
51110
51111
51112

SQL示例

添加节点
  • 依旧是在小吴下添加下属节点，在插入下属节点后，找出以小吴节点为后代的那些节点作为和下属节点之间有后代关系，插入到数据表。
-- 1.插入自己M，eid为16
INSERT INTO employees3 ( eid, ename, position )
VALUES ( 16, '小魏', '产品部员工' );
-- 2.查出以小吴为后代的节点数据
SELECT * FROM emp_relations WHERE node_id=4;
-- 3.插入到数据表：深度+1作为和M节点的深度 
INSERT INTO emp_relations ( root_id, depth, is_leaf, node_id )
VALUES
( 1, 3, 0, 16 ),
( 2, 2, 0, 16 ),
( 4, 1, 0, 16 ),
( 16, 0, 1, 16 );
查询小天的直接上司
  • 在关系表中找到node_id为小天id，depth为1的根节点id即可
SELECT
	e2.eid, e2.ename, e2.position 
FROM
	employees3 e1,
	employees3 e2,
	emp_relations rel 
WHERE
	e1.ename = '小天' 
	AND rel.node_id = e1.eid 
	AND rel.depth = 1 
	AND e2.eid = rel.root_id
查询老宋的直属员工
  • 只要查询root_id为老宋eid且深度为1的node_id即为其直接下属员工id
SELECT
	e1.eid,	e1.ename, e1.position
FROM
	employees3 e1,
	employees3 e2,
	emp_relations rel 
WHERE
	e2.ename = '老宋' 
	AND rel.root_id = e2.eid 
	AND rel.depth = 1 
	AND e1.eid = rel.node_id
查询小天的所有上司
  • 只要在关系表中找到node_id为小天eid且depth大于0的root_id即可
SELECT
	e2.eid,	e2.ename, e2.position
FROM
	employees3 e1,
	employees3 e2,
	emp_relations rel 
WHERE
	e1.ename = '小天' 
	AND rel.node_id = e1.eid 
	AND rel.depth > 0 
	AND e2.eid = rel.root_id
查询老王的所有员工
SELECT
	e1.eid,	e1.ename, e1.position 
FROM
	employees3 e1,
	employees3 e2,
	emp_relations rel 
WHERE
	e2.ename = '老王' 
	AND rel.root_id = e2.eid 
	AND rel.depth > 0 
	AND e1.eid = rel.node_id

总结

  1. Adjacency List（邻接列表）:
  • 优点：简单易于理解和实现，只需要一个父节点 ID 字段，容易添加、删除、移动节点。不需要维护冗余数据。
  • 缺点：查询层级关系和递归操作需要进行多次查询，效率较低。在大型树状结构中，查询深度可能导致性能问题。
  • 使用场景：适用于树状结构较小，层级深度不太深的情况，或者只需要简单的树结构操作。
  1. Path Enumeration（路径枚举）:
    • 优点：相比邻接列表，路径枚举能够更快速地进行递归查询和层级操作，因为路径信息已经在节点上存储。
    • 缺点：相比闭包表，会有一定的冗余，需要维护节点路径信息。对于层级关系较复杂的树结构，可能会占用更多的存储空间。
    • 使用场景：适用于树状结构的层级操作较频繁，但树结构相对不太复杂的情况。
  2. Closure Table（闭包表）:
    • 优点：能够高效地进行层级查询和递归操作，不需要多次查询数据库。对于复杂的树状结构，闭包表是一种强大的方法。
    • 缺点：闭包表引入了数据冗余，存储了所有祖先-后代对，可能会占用更多的存储空间。
    • 使用场景：适用于树状结构非常复杂的情况，或者需要高效查询祖先和后代节点关系的场景。
  • 综合考虑，选择适当的存储方法取决于树状结构的大小、层级深度、复杂性，以及对于层级查询和操作的性能需求。对于小型和简单的树结构，邻接列表是一个简单有效的选择。对于较大且层级深度较深的树结构，Closure Table 提供了更高效的查询方式。而路径枚举则在某些情况下可以作为一种折中方案，同时满足查询效率和数据冗余的需求。
Cyborg2077
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
在数据库中储存树形结构
北鹤M的代码手账
01-14 7458
树是表示层次结构的方法之一，因此可用于许多问题域。本文通过一个简单问题域中的示例，讨论了在RDBMS中表示树的四种最受欢迎的方法。 以树状结构表示和存储数据是软件开发中的常见问题： XML / Markup语法解析器（例如Apache Xerces和Xalan XSLt）使用树； PDF使用以下树结构：根节点->目录节点->页面节点->子页面节点。通常，PDF文件在内存中表示为平衡树。 多种科学和游戏应用程序使用决策树，概率树，行为树；Flare可视化库（http://flare.pre
如何在数据库中存储一棵树
weixin_33751566的博客
06-21 1351
树形结构的数据在项目开发中比较常见，比如比较典型的是论坛主题留言。每一个主题（节点）可以有n个留言（子节点）。这些留言又可以有自己的留言。因此这种结构就是一颗树。本文讨论的是数据库中如何存储这种树形结构。假设有如下一棵树：方法一注意：本例中的数据库是SQLite，因此SQL语句只对SQLite有效，其他数据库可以参考该写法。要存储于数据库中，最简单直接的方法，就是存储每个元素的父节点ID。暂且把这...
【mysql&算法】在数据库中储存树形结构
最新发布
weixin_44823875的博客
08-14 1699
图论中的邻接表是一种通过存储每个顶点的邻居列表（即相邻顶点）来表示图的方法。对于树，可以仅存储父节点，然后每个列表都包含一个值，该值可以与顶点一起存储在数据库中。这是最流行的表示形式之一，也是最直观的表示形式：表仅具有对自身的引用（图2）。然后，根节点NULL的父节点包含一个空值（）。此方法的主要数据选择操作要求DBMS支持递归查询。PostgreSQL支持这种类型的查询，但是对于不支持DBMS的用户，可能需要通过使用临时表和存储过程来执行选择。以下是一些查询示例。（1）获取给定节点的子树。
数据库树形结构存储方法的选择
wangzibai的博客
02-04 3789
树形结构存储方法的选择 简单的方法跟踪多级回复构成的树形分支：parent_id 一开始的思路 使用parent_id跟踪分支 使用先找出所有节点，按照一定顺序整合成树形结构 缺陷： 在深度过深时仅用parent_id需要执行很多次SQL才能获取给定主题的所有数据 每天的数据变动可能非常大，每访问一次整合一次过于浪费时间且不切实际 目标：一个更好的存储多级结构及简单高效获取一个完整分支的方法 分层存储合查询 树形结构举例：组织架构图、线程化讨论 解决方案 邻接表 依赖父节点构成的邻接表，由paren
mysql数据库存储树形结构的三种方式
csgarten的博客
09-16 3054
mysql存储树形结构
聊聊树状结构如何在数据库中存储
12-14
昨天有人在QQ小组问起，无限分层的树状结构，数据量比较大，在一万条以上，如何设计数据库的结构。其实这是个老生常谈的问题，一般的做法是有一个 pid字段，为了提高效率，还会有个FullPath字段。(一些人还设置一个...
树状数据（多叉树）在数据库中存储的示例源码
03-01
本主要是树状数据（多叉树）在数据库中存储的示例源码，同时包含数据表的设计示例，满满的代码干货
动态数据库实现树状结构.txt
04-16
动态数据库实现树状结构 动态数据库实现树状结构.
使用MongoDB存储类似层次结构的树
04-04
在MongoDB中使用NoSQL数据库存储树状结构的三种方法
VC++通信录（带首拼检索，树状结构显示）
05-12
利用V++开发的通信录管理小程序，树状结构显示姓名和分类，可根据人员的姓名首拼检索定位人员姓名，人员存储access数据库，请多批评指正！
树形结构数据库设计和显示
08-22
树形结构数据库设计，和java获取json到前台显示。
关系数据库表存储树形结构的方法
03-03
关系数据库表存储树形结构的方法； 单数据库表的实现； 多数据库表的实现；
树形结构的数据库表Schema设计
热门推荐
愤怒的小狐狸----博客专栏
07-30 8万+
树形结构的数据库表Schema设计：一种基于左、右值编码前序遍历的树形结构数据库表Schema设计方案，消除了频繁的“递归”操作，提升了树形结构查询效率~
mysql数据库递归查询树形结构（适用场景：菜单多级分类，多级关联评论查询），用strea流把list转成树的方法详解
qq_26112725的博客
03-22 6407
mysql数据库递归查询树形结构（适用场景：菜单多级分类，多级关联评论查询），用strea流把list转成树的方法详解
数据库基础之树形查询结构设计
小明的博客
09-07 791
树形数据结构是我们常见的一种数据结构，比如文件目录、公司组织结构等。但是关系型数据库却没有对应的原生数据结构去存储查询这种数据结构，本文介绍了几种实现关系型数据库树形数据存储的方式供大家参考。 前言 树形结构是生活中常见的数据结构之一，如公司的组织结构、计算机文件的目录结构和家庭族谱等。本文将以区域作为示例，介绍几种常见的数据库实现树形查询的方式： 树形结构的关键属性：深度 方案一、毗邻目录模式(adjacency list model) 方案原理 毗邻目录模式在树形结构数据的每条记录中，记录了指向父数据
树结构如何在关系型数据库中存储
一叶知春秋
04-25 2937
树结构数据如何在数据库中存储（优化方案）
树状结构数据的数据库表设计及使用 - 1. 邻接表
不吃_花椒的博客
06-22 6540
树状结构或层次结构的数据在企业应用里非常常见，例如公司的组织架构、文档库的目录结构、仓库的库位组织以及物件的分类等等。通常的树状图是一种数据结构。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：每个结点有零个或多个子结点；没有父结点的结点称为根结点；每一个非根结点有且只有一个父结点；除了根结点外，每个子结点可以分为多个不相交的子树。树结构是一种非线性存储结构，存储的是具有“一对多”关系的数据元素的集合。在设计树状结构的数据库表的时候，大部分开发者会下意识的选择邻
逻辑数据库设计 - 单纯的树(递归关系数据)
ajwqb06628的专栏
09-03 2035
逻辑数据库设计 - 单纯的树(递归关系数据) 　　相信有过开发经验的朋友都曾碰到过这样一个需求。假设你正在为一个新闻网站开发一个评论功能，读者可以评论原文甚至相互回复。 　　这个需求并不简单，相互回复会导致无限多的分支，无限多的祖先-后代关系。这是一种典型的递归关...
数据库存储树形结构的数据
lee576的专栏
02-05 3万+
最近接触树形结构数据非常的多,几乎超过了过去8年多,开发所有系统的总和.本来嘛,一般的递归就可以解决了,可是这个系统中总是需要频繁的访问树结点,及父结点,子结点,动不动就要递归,且树的使用非常之多,做的多了搞的人都要呕吐了,下面在网上找到几篇比较有用的资料,记录汇总一下.首先,数据库不一定要用传统的关系型数据库,因为传统关系库有一些很难做到或者做起来非常麻烦的功能,尤其是父子关系特别复杂的时候,这
mysql数据库实现jsp树状图_数据库中树形结构怎么样在jsp中显示
05-14
要在 JSP 中显示数据库中的树形结构，需要先将树形结构存储在数据库中。MySQL 中可以使用以下两种方法来实现树形结构： 1. 使用嵌套集模型（Nested Set Model）：该模型将每个节点表示为一对数字，即左值和右值。每个节点都有一个左值和右值，代表该节点在树形结构中的位置。使用该模型可以方便地查询子节点和父节点，但是需要在插入、删除、移动节点时维护左值和右值的正确性。 2. 使用邻接表模型（Adjacency List Model）：该模型将每个节点表示为一行记录，每行记录包含节点的 ID、父节点的 ID 和节点的名称等信息。使用该模型可以方便地查询子节点和父节点，但是查询多层子节点时需要使用递归查询，效率较低。 在 JSP 中显示树形结构可以使用递归查询进行实现。例如，可以使用 Java 的 List 和 Map 数据结构来存储数据库中的树形结构，并使用递归函数将树形结构转换为 HTML 中的 ul 和 li 标签，从而实现树形结构的展示。以下是一个简单的示例代码： ``` <%@ page import="java.util.List" %> <%@ page import="java.util.Map" %> <% // 获取数据库中的树形结构并存储到 List 和 Map 中 List<Map<String, Object>> treeData = getTreeData(); Map<Integer, List<Map<String, Object>>> childMap = getChildMap(treeData); // 使用递归函数将树形结构转换为 HTML 标签 out.print("<ul>"); printTree(treeData, childMap, 0); out.print("</ul>"); // 递归函数，将树形结构转换为 HTML 标签 void printTree(List<Map<String, Object>> treeData, Map<Integer, List<Map<String, Object>>> childMap, int parentId) { List<Map<String, Object>> children = childMap.get(parentId); if (children != null) { for (Map<String, Object> child : children) { int id = (Integer) child.get("id"); String name = (String) child.get("name"); out.print("<li>" + name + "</li>"); out.print("<ul>"); printTree(treeData, childMap, id); out.print("</ul>"); } } } // 获取数据库中的树形结构 List<Map<String, Object>> getTreeData() { // TODO: 从数据库中查询树形结构并返回 } // 将树形结构存储到 Map 中，以便递归查询子节点 Map<Integer, List<Map<String, Object>>> getChildMap(List<Map<String, Object>> treeData) { Map<Integer, List<Map<String, Object>>> childMap = new HashMap<>(); for (Map<String, Object> node : treeData) { int parentId = (Integer) node.get("parent_id"); if (!childMap.containsKey(parentId)) { childMap.put(parentId, new ArrayList<>()); } childMap.get(parentId).add(node); } return childMap; } %> ``` 在以上代码中，getTreeData() 函数用于从数据库中获取树形结构并返回，getChildMap() 函数用于将树形结构存储到 Map 中以便递归查询子节点，printTree() 函数用于递归转换树形结构为 HTML 标签，并最终输出到 JSP 页面中。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值