多级分类商品类目实现：让树形结构如丝般顺滑！🌲

标题： 多级分类还在用递归？四种方案让你眼前一亮！
副标题： 从邻接表到路径枚举，无限级分类全攻略

---

🎬 开篇：一次糟糕的分类查询

电商网站商品分类：

用户点击"电脑 > 笔记本 > 游戏本"

后端：SELECT * FROM category WHERE parent_id = ?
      递归查询了10次... 💀
      
响应时间：3秒
用户体验：💩
老板：为什么这么慢？

开发：我用了递归啊...
老板：换个方案！

改用路径枚举后：
查询次数：1次  ⚡
响应时间：50ms  🚀
老板：这才对嘛！😄

教训：树形结构的实现方案直接影响性能！

🤔 什么是多级分类？

想象你的衣柜：

• 顶层： 衣服、鞋子、配饰
• 二层： 上衣、裤子、外套...
• 三层： T恤、衬衫、卫衣...
• 四层： 短袖T恤、长袖T恤...

多级分类 = 树形结构，可以无限层级！

---

📚 知识地图

多级分类四大实现方案
├── 🔗 邻接表（Adjacency List）- 最简单
├── 📍 路径枚举（Path Enumeration）- 推荐！
├── 🎯 嵌套集合（Nested Set）- 查询快
└── 📊 闭包表（Closure Table）- 最灵活

---

🔗 方案1：邻接表（传统方案）

🌰 生活中的例子

家谱：

• 每个人记录父亲是谁
• 要找祖先？一代代往上查

💻 数据库设计

-- 邻接表结构
CREATE TABLE category (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(50) NOT NULL COMMENT '分类名称',
    parent_id BIGINT NOT NULL DEFAULT 0 COMMENT '父分类ID',
    level INT NOT NULL DEFAULT 1 COMMENT '层级',
    sort INT NOT NULL DEFAULT 0 COMMENT '排序',
    icon VARCHAR(100) COMMENT '图标',
    status TINYINT NOT NULL DEFAULT 1 COMMENT '状态',
    create_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
    INDEX idx_parent_id (parent_id),
    INDEX idx_level (level)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='商品分类表（邻接表）';

-- 示例数据
INSERT INTO category (id, name, parent_id, level) VALUES
(1, '电脑办公', 0, 1),
  (2, '笔记本', 1, 2),
    (3, '游戏本', 2, 3),
    (4, '轻薄本', 2, 3),
  (5, '台式机', 1, 2),
(6, '手机', 0, 1),
  (7, 'iPhone', 6, 2),
  (8, '安卓手机', 6, 2);

Java实现

/**
 * 邻接表方案实现
 */
@Service
public class AdjacencyListCategoryService {
    
    @Autowired
    private CategoryMapper categoryMapper;
    
    /**
     * 查询所有分类（树形结构）
     * ❌ 递归查询，性能差
     */
    public List<CategoryVO> getCategoryTree() {
        // 1. 查询所有顶级分类
        List<Category> topCategories = categoryMapper.selectByParentId(0L);
        
        // 2. 递归查询子分类
        return topCategories.stream()
            .map(this::buildCategoryTree)
            .collect(Collectors.toList());
    }
    
    /**
     * 递归构建分类树（性能差！）
     */
    private CategoryVO buildCategoryTree(Category category) {
        CategoryVO vo = new CategoryVO();
        BeanUtils.copyProperties(category, vo);
        
        // 💀 递归查询子分类（每次都要查数据库）
        List<Category> children = categoryMapper.selectByParentId(category.getId());
        
        if (!children.isEmpty()) {
            vo.setChildren(
                children.stream()
                    .map(this::buildCategoryTree)  // 递归
                    .collect(Collectors.toList())
            );
        }
        
        return vo;
    }
    
    /**
     * 优化：一次查询所有分类，内存中构建树
     * ✅ 性能大幅提升
     */
    public List<CategoryVO> getCategoryTreeOptimized() {
        // 1. 一次性查询所有分类
        List<Category> allCategories = categoryMapper.selectAll();
        
        // 2. 按parent_id分组
        Map<Long, List<Category>> parentMap = allCategories.stream()
            .collect(Collectors.groupingBy(Category::getParentId));
        
        // 3. 构建树形结构
        return buildTree(0L, parentMap);
    }
    
    /**
     * 构建树形结构（内存操作，快！）
     */
    private List<CategoryVO> buildTree(Long parentId, 
                                       Map<Long, List<Category>> parentMap) {
        List<Category> children = parentMap.get(parentId);
        
        if (children == null || children.isEmpty()) {
            return Collections.emptyList();
        }
        
        return children.stream()
            .map(category -> {
                CategoryVO vo = new CategoryVO();
                BeanUtils.copyProperties(category, vo);
                
                // 递归查找子节点（内存操作，不查数据库）
                vo.setChildren(buildTree(category.getId(), parentMap));
                
                return vo;
            })
            .collect(Collectors.toList());
    }
    
    /**
     * 查询所有父级分类
     * ❌ 递归查询，性能差
     */
    public List<Category> getParents(Long categoryId) {
        List<Category> parents = new ArrayList<>();
        
        Category current = categoryMapper.selectById(categoryId);
        
        while (current != null && current.getParentId() != 0) {
            Category parent = categoryMapper.selectById(current.getParentId());
            if (parent != null) {
                parents.add(0, parent);  // 添加到列表开头
            }
            current = parent;
        }
        
        return parents;
    }
}

/**
 * 优点：
 * ✅ 结构简单，易于理解
 * ✅ 插入、更新操作简单
 * ✅ 移动节点方便（只需更新parent_id）
 * 
 * 缺点：
 * ❌ 查询效率低（需要递归）
 * ❌ 查询父节点链路需要多次查询
 * ❌ 层级深时性能差
 * 
 * 适用场景：
 * ✅ 层级较少（3层以内）
 * ✅ 查询频率不高
 * ✅ 结构变动频繁
 */

---

📍 方案2：路径枚举（推荐！）

🌰 生活中的例子

文件路径：

• /home/user/documents/work/report.pdf
• 一眼就能看出层级关系
• 查找父目录：直接截取路径

💻 数据库设计

-- 路径枚举结构
CREATE TABLE category_path (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(50) NOT NULL COMMENT '分类名称',
    parent_id BIGINT NOT NULL DEFAULT 0 COMMENT '父分类ID',
    path VARCHAR(500) NOT NULL COMMENT '路径：1/2/3',
    level INT NOT NULL DEFAULT 1 COMMENT '层级',
    sort INT NOT NULL DEFAULT 0 COMMENT '排序',
    create_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
    INDEX idx_parent_id (parent_id),
    INDEX idx_path (path),
    INDEX idx_level (level)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='商品分类表（路径枚举）';

-- 示例数据
INSERT INTO category_path (id, name, parent_id, path, level) VALUES
(1, '电脑办公', 0, '1', 1),
  (2, '笔记本', 1, '1/2', 2),
    (3, '游戏本', 2, '1/2/3', 3),
    (4, '轻薄本', 2, '1/2/4', 3),
  (5, '台式机', 1, '1/5', 2),
(6, '手机', 0, '6', 1),
  (7, 'iPhone', 6, '6/7', 2),
  (8, '安卓手机', 6, '6/8', 2);

Java实现

/**
 * 路径枚举方案实现
 */
@Service
public class PathEnumerationCategoryService {
    
    @Autowired
    private CategoryPathMapper categoryMapper;
    
    /**
     * 添加分类
     */
    @Transactional(rollbackFor = Exception.class)
    public Long addCategory(CategoryDTO dto) {
        CategoryPath category = new CategoryPath();
        category.setName(dto.getName());
        category.setParentId(dto.getParentId());
        category.setSort(dto.getSort());
        
        // ⚡ 构建路径
        if (dto.getParentId() == 0) {
            // 顶级分类
            category.setLevel(1);
            // path在插入后设置为自己的ID
        } else {
            // 子分类
            CategoryPath parent = categoryMapper.selectById(dto.getParentId());
            if (parent == null) {
                throw new BusinessException("父分类不存在");
            }
            
            category.setLevel(parent.getLevel() + 1);
        }
        
        categoryMapper.insert(category);
        
        // 更新path
        if (dto.getParentId() == 0) {
            category.setPath(String.valueOf(category.getId()));
        } else {
            CategoryPath parent = categoryMapper.selectById(dto.getParentId());
            category.setPath(parent.getPath() + "/" + category.getId());
        }
        
        categoryMapper.updateById(category);
        
        return category.getId();
    }
    
    /**
     * 查询所有子分类（包括孙子...）
     * ⚡ 一次查询搞定！
     */
    public List<CategoryPath> getAllChildren(Long categoryId) {
        CategoryPath category = categoryMapper.selectById(categoryId);
        
        if (category == null) {
            return Collections.emptyList();
        }
        
        // ⚡ 使用LIKE查询，path以"1/2/"开头的都是子孙节点
        return categoryMapper.selectByPathPrefix(category.getPath() + "/");
    }
    
    /**
     * 查询所有父分类
     * ⚡ 一次查询搞定！
     */
    public List<CategoryPath> getAllParents(Long categoryId) {
        CategoryPath category = categoryMapper.selectById(categoryId);
        
        if (category == null || category.getParentId() == 0) {
            return Collections.emptyList();
        }
        
        // 解析path：1/2/3 -> [1, 2]
        String[] ids = category.getPath().split("/");
        List<Long> parentIds = Arrays.stream(ids)
            .limit(ids.length - 1)  // 去掉最后一个（自己）
            .map(Long::parseLong)
            .collect(Collectors.toList());
        
        if (parentIds.isEmpty()) {
            return Collections.emptyList();
        }
        
        // ⚡ 一次性查询所有父分类
        return categoryMapper.selectByIds(parentIds);
    }
    
    /**
     * 移动分类（更新path）
     */
    @Transactional(rollbackFor = Exception.class)
    public void moveCategory(Long categoryId, Long newParentId) {
        CategoryPath category = categoryMapper.selectById(categoryId);
        CategoryPath newParent = categoryMapper.selectById(newParentId);
        
        if (category == null || newParent == null) {
            throw new BusinessException("分类不存在");
        }
        
        // 防止移动到自己的子节点下
        if (newParent.getPath().startsWith(category.getPath() + "/")) {
            throw new BusinessException("不能移动到自己的子节点下");
        }
        
        String oldPath = category.getPath();
        String newPath = newParent.getPath() + "/" + category.getId();
        
        // 1. 更新自己的path
        category.setPath(newPath);
        category.setParentId(newParentId);
        category.setLevel(newParent.getLevel() + 1);
        categoryMapper.updateById(category);
        
        // 2. ⚡ 更新所有子孙节点的path
        categoryMapper.updateChildrenPath(oldPath, newPath);
        
        log.info("分类移动成功：categoryId={}, oldPath={}, newPath={}", 
            categoryId, oldPath, newPath);
    }
    
    /**
     * 删除分类（级联删除子分类）
     */
    @Transactional(rollbackFor = Exception.class)
    public void deleteCategory(Long categoryId) {
        CategoryPath category = categoryMapper.selectById(categoryId);
        
        if (category == null) {
            return;
        }
        
        // ⚡ 删除自己和所有子孙节点
        categoryMapper.deleteByPathPrefix(category.getPath());
        
        log.info("分类删除成功：categoryId={}, path={}", categoryId, category.getPath());
    }
}

/**
 * Mapper实现
 */
@Mapper
public interface CategoryPathMapper extends BaseMapper<CategoryPath> {
    
    /**
     * 根据路径前缀查询
     */
    @Select("SELECT * FROM category_path " +
            "WHERE path LIKE CONCAT(#{pathPrefix}, '%') " +
            "ORDER BY path")
    List<CategoryPath> selectByPathPrefix(@Param("pathPrefix") String pathPrefix);
    
    /**
     * 批量更新子节点路径
     */
    @Update("UPDATE category_path " +
            "SET path = REPLACE(path, #{oldPath}, #{newPath}), " +
            "    level = level + #{levelDiff} " +
            "WHERE path LIKE CONCAT(#{oldPath}, '/%')")
    int updateChildrenPath(@Param("oldPath") String oldPath, 
                          @Param("newPath") String newPath,
                          @Param("levelDiff") int levelDiff);
    
    /**
     * 根据路径前缀删除
     */
    @Delete("DELETE FROM category_path " +
            "WHERE path = #{path} OR path LIKE CONCAT(#{path}, '/%')")
    int deleteByPathPrefix(@Param("path") String path);
    
    /**
     * 批量查询
     */
    @Select("<script>" +
            "SELECT * FROM category_path " +
            "WHERE id IN " +
            "<foreach collection='ids' item='id' open='(' separator=',' close=')'>" +
            "#{id}" +
            "</foreach>" +
            "ORDER BY path" +
            "</script>")
    List<CategoryPath> selectByIds(@Param("ids") List<Long> ids);
}

/**
 * 优点：
 * ✅ 查询性能好（一次SQL搞定）
 * ✅ 查询父节点、子节点都很快
 * ✅ 路径清晰，易于理解
 * 
 * 缺点：
 * ⚠️ path字段占用空间
 * ⚠️ 移动节点需要更新所有子节点
 * ⚠️ path长度有限制
 * 
 * 适用场景：
 * ✅ 查询频繁（推荐）⭐⭐⭐⭐⭐
 * ✅ 层级较深
 * ✅ 结构相对稳定
 */

---

🎯 方案3：嵌套集合（Nested Set）

🌰 生活中的例子

俄罗斯套娃：

• 大娃包含中娃
• 中娃包含小娃
• 通过左右边界判断包含关系

💻 数据库设计

-- 嵌套集合结构
CREATE TABLE category_nested (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(50) NOT NULL,
    lft INT NOT NULL COMMENT '左边界',
    rgt INT NOT NULL COMMENT '右边界',
    level INT NOT NULL DEFAULT 1,
    INDEX idx_lft_rgt (lft, rgt)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='商品分类表（嵌套集合）';

-- 示例数据（左右边界）
-- 电脑办公(1-10)
--   笔记本(2-7)
--     游戏本(3-4)
--     轻薄本(5-6)
--   台式机(8-9)
-- 手机(11-16)
--   iPhone(12-13)
--   安卓手机(14-15)

INSERT INTO category_nested (id, name, lft, rgt, level) VALUES
(1, '电脑办公', 1, 10, 1),
  (2, '笔记本', 2, 7, 2),
    (3, '游戏本', 3, 4, 3),
    (4, '轻薄本', 5, 6, 3),
  (5, '台式机', 8, 9, 2),
(6, '手机', 11, 16, 1),
  (7, 'iPhone', 12, 13, 2),
  (8, '安卓手机', 14, 15, 2);

Java实现

/**
 * 嵌套集合方案实现
 */
@Service
public class NestedSetCategoryService {
    
    @Autowired
    private CategoryNestedMapper categoryMapper;
    
    /**
     * 查询所有子节点
     * ⚡ 一次查询搞定！
     */
    public List<CategoryNested> getAllChildren(Long categoryId) {
        CategoryNested category = categoryMapper.selectById(categoryId);
        
        if (category == null) {
            return Collections.emptyList();
        }
        
        // ⚡ 子节点的lft在父节点的(lft, rgt)之间
        return categoryMapper.selectChildren(category.getLft(), category.getRgt());
    }
    
    /**
     * 查询所有父节点
     * ⚡ 一次查询搞定！
     */
    public List<CategoryNested> getAllParents(Long categoryId) {
        CategoryNested category = categoryMapper.selectById(categoryId);
        
        if (category == null) {
            return Collections.emptyList();
        }
        
        // ⚡ 父节点的(lft, rgt)包含当前节点的lft
        return categoryMapper.selectParents(category.getLft(), category.getRgt());
    }
    
    /**
     * 查询整棵树
     * ⚡ 一次查询，按lft排序即可
     */
    public List<CategoryNested> getTree() {
        return categoryMapper.selectAllOrderByLft();
    }
}

@Mapper
public interface CategoryNestedMapper extends BaseMapper<CategoryNested> {
    
    /**
     * 查询子节点
     */
    @Select("SELECT * FROM category_nested " +
            "WHERE lft > #{parentLft} AND rgt < #{parentRgt} " +
            "ORDER BY lft")
    List<CategoryNested> selectChildren(@Param("parentLft") Integer parentLft,
                                       @Param("parentRgt") Integer parentRgt);
    
    /**
     * 查询父节点
     */
    @Select("SELECT * FROM category_nested " +
            "WHERE lft < #{childLft} AND rgt > #{childRgt} " +
            "ORDER BY lft")
    List<CategoryNested> selectParents(@Param("childLft") Integer childLft,
                                      @Param("childRgt") Integer childRgt);
    
    /**
     * 查询所有（按左边界排序）
     */
    @Select("SELECT * FROM category_nested ORDER BY lft")
    List<CategoryNested> selectAllOrderByLft();
}

/**
 * 优点：
 * ✅ 查询性能极好
 * ✅ 一次SQL查询整棵树
 * ✅ 统计子节点数量简单：(rgt-lft-1)/2
 * 
 * 缺点：
 * ❌ 插入、删除、移动操作复杂
 * ❌ 需要更新大量节点的lft/rgt
 * ❌ 并发更新容易出错
 * 
 * 适用场景：
 * ✅ 读多写少
 * ✅ 需要频繁查询整棵树
 * ✅ 结构基本不变
 */

---

📊 方案4：闭包表（Closure Table）

💻 数据库设计

-- 分类表
CREATE TABLE category_closure (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(50) NOT NULL,
    level INT NOT NULL DEFAULT 1
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- 关系表（核心！）
CREATE TABLE category_relation (
    ancestor BIGINT NOT NULL COMMENT '祖先节点',
    descendant BIGINT NOT NULL COMMENT '后代节点',
    distance INT NOT NULL COMMENT '距离（层级差）',
    PRIMARY KEY (ancestor, descendant),
    INDEX idx_ancestor (ancestor),
    INDEX idx_descendant (descendant),
    INDEX idx_distance (distance)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='分类关系表';

-- 示例数据
-- 电脑办公(1) -> 笔记本(2) -> 游戏本(3)

INSERT INTO category_relation (ancestor, descendant, distance) VALUES
-- 电脑办公的关系
(1, 1, 0),  -- 自己到自己
(1, 2, 1),  -- 到笔记本
(1, 3, 2),  -- 到游戏本
-- 笔记本的关系
(2, 2, 0),  -- 自己到自己
(2, 3, 1),  -- 到游戏本
-- 游戏本的关系
(3, 3, 0);  -- 自己到自己

Java实现

/**
 * 闭包表方案实现
 */
@Service
public class ClosureTableCategoryService {
    
    @Autowired
    private CategoryClosureMapper categoryMapper;
    
    @Autowired
    private CategoryRelationMapper relationMapper;
    
    /**
     * 添加分类
     */
    @Transactional(rollbackFor = Exception.class)
    public Long addCategory(String name, Long parentId, int level) {
        // 1. 插入分类
        CategoryClosure category = new CategoryClosure();
        category.setName(name);
        category.setLevel(level);
        categoryMapper.insert(category);
        
        // 2. ⚡ 插入关系（自己到自己）
        relationMapper.insertRelation(category.getId(), category.getId(), 0);
        
        // 3. ⚡ 插入与所有祖先的关系
        if (parentId != null && parentId != 0) {
            relationMapper.insertParentRelations(category.getId(), parentId);
        }
        
        return category.getId();
    }
    
    /**
     * 查询所有子节点
     */
    public List<CategoryClosure> getAllChildren(Long categoryId) {
        return categoryMapper.selectChildren(categoryId);
    }
    
    /**
     * 查询所有父节点
     */
    public List<CategoryClosure> getAllParents(Long categoryId) {
        return categoryMapper.selectParents(categoryId);
    }
    
    /**
     * 查询直接子节点
     */
    public List<CategoryClosure> getDirectChildren(Long categoryId) {
        return categoryMapper.selectDirectChildren(categoryId);
    }
    
    /**
     * 移动节点
     */
    @Transactional(rollbackFor = Exception.class)
    public void moveCategory(Long categoryId, Long newParentId) {
        // 1. 删除旧的祖先关系（不包括自己）
        relationMapper.deleteAncestorRelations(categoryId);
        
        // 2. 插入新的祖先关系
        relationMapper.insertParentRelations(categoryId, newParentId);
    }
    
    /**
     * 删除节点（级联删除）
     */
    @Transactional(rollbackFor = Exception.class)
    public void deleteCategory(Long categoryId) {
        // 1. 删除所有相关关系
        relationMapper.deleteAllRelations(categoryId);
        
        // 2. 删除分类
        categoryMapper.deleteById(categoryId);
    }
}

@Mapper
public interface CategoryRelationMapper {
    
    /**
     * 插入关系
     */
    @Insert("INSERT INTO category_relation (ancestor, descendant, distance) " +
            "VALUES (#{ancestor}, #{descendant}, #{distance})")
    int insertRelation(@Param("ancestor") Long ancestor,
                      @Param("descendant") Long descendant,
                      @Param("distance") Integer distance);
    
    /**
     * 插入与父节点及其祖先的关系
     */
    @Insert("INSERT INTO category_relation (ancestor, descendant, distance) " +
            "SELECT ancestor, #{categoryId}, distance + 1 " +
            "FROM category_relation " +
            "WHERE descendant = #{parentId}")
    int insertParentRelations(@Param("categoryId") Long categoryId,
                             @Param("parentId") Long parentId);
    
    /**
     * 删除祖先关系
     */
    @Delete("DELETE FROM category_relation " +
            "WHERE descendant = #{categoryId} AND ancestor != #{categoryId}")
    int deleteAncestorRelations(@Param("categoryId") Long categoryId);
    
    /**
     * 删除所有相关关系
     */
    @Delete("DELETE FROM category_relation " +
            "WHERE ancestor = #{categoryId} OR descendant = #{categoryId}")
    int deleteAllRelations(@Param("categoryId") Long categoryId);
}

/**
 * 优点：
 * ✅ 查询性能好
 * ✅ 移动节点相对简单
 * ✅ 支持复杂查询（如共同祖先）
 * 
 * 缺点：
 * ⚠️ 需要额外的关系表
 * ⚠️ 空间占用大
 * ⚠️ 维护关系复杂
 * 
 * 适用场景：
 * ✅ 需要复杂查询
 * ✅ 结构经常变动
 * ✅ 对空间不敏感
 */

---

📊 方案对比总结

方案	查询性能	插入性能	移动性能	空间占用	推荐度
邻接表	差	好	好	小	⭐⭐
路径枚举	好	好	中	中	⭐⭐⭐⭐⭐
嵌套集合	极好	差	差	小	⭐⭐⭐
闭包表	好	中	中	大	⭐⭐⭐⭐

---

✅ 最佳实践

生产环境推荐：路径枚举

设计要点：
□ 优先选择路径枚举方案
□ path长度预留充足（VARCHAR(500)）
□ 添加level字段（加速查询）
□ 添加sort字段（控制排序）
□ 定期维护数据完整性

性能优化：
□ 为path建立索引
□ 一次查询所有数据，内存构建树
□ 使用Redis缓存分类树
□ 定时刷新缓存

用户体验：
□ 面包屑导航（父级路径）
□ 懒加载子分类
□ 拖拽排序
□ 批量操作

监控维护：
□ 检测path完整性
□ 检测循环引用
□ 统计各级分类数量
□ 清理无效分类

---

🎉 总结

核心要点

多级分类实现方案选择：

1️⃣ 通用场景 -> 路径枚举（推荐）⭐⭐⭐⭐⭐
   - 查询快
   - 实现简单
   - 维护方便

2️⃣ 只读场景 -> 嵌套集合
   - 查询极快
   - 不适合频繁更新

3️⃣ 复杂查询 -> 闭包表
   - 功能最强
   - 空间占用大

4️⃣ 简单场景 -> 邻接表
   - 最简单
   - 性能一般

关键优化：
- 一次查询+内存构建树
- Redis缓存
- 合理的索引

---

记住：选对方案，性能提升10倍不是梦！ 🌲

---

文档编写时间：2025年10月24日
作者：热爱数据结构的树形工程师
版本：v1.0
愿你的分类树枝繁叶茂！ 🌲✨