尝试创建一个图，这看起来像是一个两部分的解决方案，因为你可能有循环依赖关系，直到整个对象被解析，你才知道。创建图形后，可以开始递归弹出节点并将它们添加到新对象。

你有

digraph {
    a -> b  a -> q
    b -> c [color=red]  b -> f
    c -> d
    p -> o
    d
    e -> c [color=red]
    q
    // Z->a Z->c Z->e Z->p
}

首先删除重复连接（红色）
第二，构建图表
第三，将所有无父节点添加到根节点
https://tsplay.dev/m3v71N

// convert to edge array for simplicity
const edges = Object.entries(data).flatMap(([k, v]) => v.map(e => [k, e]))
console.log(edges)

// list all nodes
let nodes = Object.entries(data).flat(2)
nodes = Array.from(new Set(nodes)).sort()
console.log(nodes)

// filter out red edges
const goodEdges = edges.filter((a) => edges.filter(b => b[1] === a[1]).length === 1)
console.log(goodEdges)

// add root edges to missing node
nodes.map(e => goodEdges.find(a => a[1] === e) || goodEdges.push(['$', e]))
console.log(goodEdges)

// create nodes
let nodeInstances = Object.fromEntries(nodes.map(e => [e, {} as Record<string, any>]))
nodeInstances.$ = {};
console.log(nodeInstances)

// build tree
goodEdges.map(e => nodeInstances[e[0]][e[1]] = nodeInstances[e[1]])

// return tree
console.log(nodeInstances.$)

首先，我们来看看有多个父母的孩子：将所有数组成员收集到一个数组中，并标识其中的重复项。
然后确定结果中应该是顶层关键字的关键字：这些是不作为子项出现的键，或者是它们之间的副本。
然后，您可以使用深度优先遍历，并为每个访问的键创建一个节点对象。不要为重复项创建节点条目，除非在顶层。

const exclude = (arr, omitSet) => arr.filter(val => !omitSet.has(val));

const duplicateSet = (arr) =>
    new Set(arr.filter(function (val) {
        return !this.delete(val);
    }, new Set(arr)));

function toNested(data) {
    const nodes = {};
    const descendants = Object.values(data).flat();
    const withMultipleParents = duplicateSet(descendants);
    const withSingleParents = new Set(exclude(descendants, withMultipleParents));
    const withNoParents = [...exclude(Object.keys(data), withSingleParents), ...withMultipleParents];
    
    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);
        }
        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(toNested(data));