从依赖关系对象构建嵌套树结构教程-js教程-PHP中文网

从依赖关系对象构建嵌套树结构教程

本教程详细阐述如何将一个项目依赖关系对象转换为一个无环的嵌套树状结构，类似于文件目录。核心方法包括识别具有多重父级、单一父级或无父级的节点，并利用深度优先搜索（dfs）算法，结合巧妙的节点分类和缓存机制，有效处理复杂的依赖关系和潜在的循环引用，最终生成符合特定规则的层级结构。

问题概述

在软件开发或项目管理中，我们经常会遇到以键值对形式表示的依赖关系，其中键代表一个项目，值是一个数组，包含该项目所依赖的其他项目。我们的目标是将这种扁平的依赖关系映射转换为一个嵌套的树状结构，类似于文件系统中的目录和文件，同时需要遵循特定的层级构建规则，并有效避免因循环依赖导致的无限递归问题。

例如，给定以下依赖关系：

{
  'a': ['b'],
  'b': ['c'],
  'c': [],
}

登录后复制

期望生成的树状结构为：

{
  'a': {
    'b': {
      'c': {}
    }
  }
}

登录后复制

更复杂的场景可能包含多重依赖和共享依赖，例如：

{
  'a': ['b', 'q'],
  'b': ['c', 'f'],
  'c': ['d'],
  'p': ['o'],
  'o': [],
  "d": [],
  'e': ['c'],
  "q": []
}

登录后复制

期望的输出结构将是：

{
  'a': {
    'b': {
      "f": {},
    },
    'q': {},
  },
  "p": {
    'o': {},
  },
  "c": { // 注意：'c' 最初是 'b' 的依赖，但因为它也被 'e' 依赖，所以它被提升为最高层级的同级节点
    "d": {}
  },
  "e": {}
}

登录后复制

核心规则解读

为了构建正确的树结构，我们需要遵循以下三条核心规则：

无父级依赖置于顶层： 任何未被其他任何依赖项使用的依赖项（即在依赖关系图中没有入度的节点）应位于树的顶层。
单父级依赖嵌套： 如果一个依赖项只被一个父级依赖项使用，那么它应该嵌套在该父级依赖项之下，以此类推。
多父级依赖提升为同级： 如果一个依赖项被两个或更多个父级依赖项使用，它不应被嵌套在任何一个父级之下。相反，它应该作为最高层级的一个独立节点出现，与它的所有父级节点处于同一级别。

这些规则是解决问题的关键，尤其第三条规则，它要求我们动态调整节点的最终位置。

Vheer

AI图像处理平台

125

查看详情

解决方案详解

解决此问题的关键在于：首先准确识别每种类型的依赖节点（无父级、单父级、多父级），然后利用深度优先搜索（DFS）算法递归地构建树，同时确保多父级节点被正确地提升到顶层。

第一步：识别节点类型

在开始构建树之前，我们需要对所有依赖项进行分类。这包括识别哪些依赖项有多个父级，哪些只有一个父级，以及哪些没有任何父级。

收集所有子依赖项： 遍历输入对象的所有值（即依赖数组），将所有子依赖项收集到一个扁平的列表中。
识别多父级依赖： 在子依赖项列表中找出所有重复出现的项。这些重复项就是具有多个父级的依赖项。
识别单父级依赖： 从所有子依赖项中排除掉多父级依赖项，剩下的就是只被一个父级使用的依赖项。
识别顶层节点： 顶层节点包括两种情况：
- 那些在整个依赖关系中从未作为任何其他项目的依赖项出现（即没有任何父级的项目）。
- 那些被识别为多父级依赖项的项目。根据规则3，它们需要被提升到顶层。

第二步：构建树结构 (深度优先搜索)

一旦节点被分类，我们就可以使用深度优先搜索（DFS）来递归构建树。DFS函数将接收一个节点作为输入，并为其构建一个子树。

缓存机制： 为了避免循环引用导致的无限递归，以及重复计算，DFS函数应维护一个已访问节点的缓存。如果一个节点已被处理并存在于缓存中，直接返回其对应的子树对象。
条件嵌套： 在遍历一个节点的子依赖项时，只有那些被识别为“单父级依赖”的子项才会被递归地嵌套到当前节点之下。对于“多父级依赖”的子项，它们不会被嵌套，因为它们已经被指定为顶层节点。

代码实现与解析

以下是基于上述思路的JavaScript实现：

/**
 * 从数组中排除指定集合中的值
 * @param {Array} arr - 原始数组
 * @param {Set} omitSet - 包含要排除的值的Set
 * @returns {Array} 过滤后的数组
 */
const exclude = (arr, omitSet) => arr.filter(val => !omitSet.has(val));

/**
 * 识别数组中的重复项，并返回一个包含所有重复项的Set
 * 例如：[1, 2, 2, 3] => Set {2}
 * @param {Array} arr - 原始数组
 * @returns {Set} 包含所有重复值的Set
 */
const duplicateSet = (arr) =>
    new Set(arr.filter(function (val) {
        // 利用Set的delete方法特性：如果成功删除，则表示该元素之前存在
        // 再次遇到时，delete会返回false，filter会保留它，并将其添加到外部的Set中
        return !this.delete(val);
    }, new Set(arr))); // 初始Set用于追踪已见过但未删除的元素


/**
 * 将扁平的依赖关系对象转换为嵌套的树状结构
 * @param {Object} data - 键为项目，值为其依赖项数组的扁平对象
 * @returns {Object} 嵌套的树状结构
 */
function toNested(data) {
    // nodes 用于存储已构建的子树，作为缓存避免循环引用和重复构建
    const nodes = {};

    // 1. 收集所有作为依赖出现的项目（所有子节点）
    const descendants = Object.values(data).flat();

    // 2. 识别具有多个父级的依赖项
    const withMultipleParents = duplicateSet(descendants);

    // 3. 识别只具有一个父级的依赖项
    const withSingleParents = new Set(exclude(descendants, withMultipleParents));

    // 4. 识别所有顶层节点
    // 顶层节点包括：
    //   - 那些从未作为任何依赖项出现的原始键（真正的根节点）
    //   - 那些具有多个父级的依赖项（根据规则3被提升到顶层）
    const withNoParents = [
        ...exclude(Object.keys(data), withSingleParents), // 排除掉单父级子节点，剩下的要么是根，要么是多父级子节点
        ...withMultipleParents // 明确添加所有多父级子节点到顶层
    ];

    /**
     * 深度优先搜索函数，用于递归构建子树
     * @param {string} key - 当前要构建子树的节点键
     * @returns {Object} 当前节点及其嵌套子节点的对象
     */
    function dfs(key) {
        // 如果当前节点已经构建过（存在于缓存中），直接返回，避免循环引用和重复工作
        if (nodes[key]) return nodes[key];

        // 初始化当前节点的子树对象
        nodes[key] = {};

        // 遍历当前节点的直接依赖项
        for (const child of data[key] ?? []) { // 使用 ?? [] 处理没有依赖项的情况
            // 只有当子节点是“单父级依赖”时，才将其嵌套到当前节点之下
            if (withSingleParents.has(child)) {
                nodes[key][child] = dfs(child); // 递归调用DFS构建子节点的子树
            }
            // 如果子节点是“多父级依赖”，则不在此处嵌套，因为它已经被提升到顶层
        }
        return nodes[key];
    }

    // 从所有顶层节点开始构建最终的树结构
    return Object.fromEntries(withNoParents.map(key => [key, dfs(key)]));
}

// 示例数据
const data = {
    'a': ['b', 'q'],
    'b': ['c', 'f'],
    'c': ['d'],
    'p': ['o'],
    'o': [],
    "d": [],
    'e': ['c'],
    "q": []
};

console.log("输入数据:", data);
console.log("生成的树结构:", toNested(data));

/*
预期输出:
{
  a: { b: { f: {} }, q: {} },
  p: { o: {} },
  c: { d: {} },
  e: {}
}
*/

登录后复制

代码解析：

exclude(arr, omitSet): 这是一个辅助函数，用于从一个数组中过滤掉那些存在于 omitSet 中的元素。
duplicateSet(arr): 这是核心辅助函数之一。它通过巧妙地使用 Set 的 delete 方法来识别数组中的重复项。当一个元素首次被添加到 Set 时，delete 会返回 false（因为它还不存在）。当同一个元素再次出现时，delete 会成功删除它并返回 true。通过反转这个逻辑 (!this.delete(val))，我们就能筛选出那些在 Set 中被成功删除（即第二次或更多次出现）的元素，从而得到所有重复项。
toNested(data) 函数：
- nodes = {}: 一个空对象，用作缓存，存储已经构建的子树。
- descendants: 包含所有作为依赖项出现的键。
- withMultipleParents: 调用 duplicateSet 找出所有被多个父级依赖的节点。
- withSingleParents: 从所有 descendants 中排除 withMultipleParents，得到只被一个父级依赖的节点。
- withNoParents: 这是最关键的顶层节点集合。它由两部分组成：
  - exclude(Object.keys(data), withSingleParents)：从所有原始键中，排除掉那些只作为单父级依赖出现的键。这会保留真正的根节点（没有父级的）和多父级依赖节点。
  - ...withMultipleParents：将所有多父级依赖节点明确地添加到顶层节点集合中，确保它们作为独立节点出现。
- dfs(key) 函数：
  - if (nodes[key]) return nodes[key];: 这是防止循环引用和重复构建的关键。如果 key 对应的子树已经在 nodes 中，直接返回。
  - nodes[key] = {};: 初始化当前 key 的子树。
  - 遍历子依赖项： 对 data[key] 中的每个 child：
    - if (withSingleParents.has(child)): 只有当 child 是单父级依赖时，才递归调用 dfs(child) 并将其结果作为当前 key 的子节点。
    - 多父级处理： 如果 child 是多父级依赖，则不会在此处嵌套。它已经在 withNoParents 中，最终会作为顶层节点被处理。
- Object.fromEntries(withNoParents.map(key => [key, dfs(key)])): 最后，遍历所有识别出的顶层节点，为每个节点调用 dfs 函数，并将结果组合成最终的树状结构。

注意事项与总结

循环依赖处理： 解决方案通过 nodes 缓存有效地避免了因循环依赖导致的无限递归。当DFS再次遇到一个正在构建或已构建的节点时，它会直接返回已有的引用，而不会陷入死循环。
节点提升机制： 关键在于 withNoParents 的构建，它准确地将所有符合规则3的节点（多父级依赖）提升到树的顶层，而不是嵌套在任何一个父级之下。
时间复杂度： 该算法的时间复杂度主要取决于图的节点数 (V) 和边数 (E)。由于每个节点和每条边都会被访问常数次（用于分类和DFS），因此复杂度大致为 O(V + E)。
可读性和维护性： 将节点分类逻辑与树构建逻辑分离，并使用辅助函数，提高了代码的可读性和模块化。

通过这种方法，我们可以有效地将复杂的扁平依赖关系转换为符合特定业务逻辑的嵌套树结构，同时健壮地处理各种依赖场景，包括多重父级和潜在的循环引用。

以上就是从依赖关系对象构建嵌套树结构教程的详细内容，更多请关注php中文网其它相关文章！