Javascript树搜索算法，返回树的子集，其中包含找到的术语及其父项

我有一个树选择，其中每个节点都有一个名称。我想搜索节点名称并返回树的子集，其中只包含找到的节点及其父节点

有人知道JavaScript中有一种有效的算法可以解决这个问题，它返回节点及其所有父节点

这里有一个例子。当用户键入搜索词时，例如“大象”，树如下所示：

• 象
  • 仓鼠
    • 鱼
  • 鸭子
• 仓鼠
  • 狗
    • 鱼
  • 象
    • 鱼
• 狗
  • 鱼
    • 独角兽
      • 象
    • 象
    • 仓鼠
  • 独角兽
• 象
  • 仓鼠
    • 鱼
    • 象
    • 象
  • 象

---

要以树格式输出搜索结果，子级如下：

• 象
• 仓鼠
  • 象
• 狗
  • 鱼
    • 独角兽
      • 象
    • 象
• 象
  • 仓鼠
    • 象
    • 象
  • 象

鉴于：

this.tree =[
 {childs: Array(2), id: 2, name: "Elephant",  …}
 {childs: Array(2), id: 3, name: "Hamster", ...}
 {childs: Array(2), id: 3, name: "Dog", ...}
 {childs: Array(2), id: 3, name: "Elephant", ...}
]

给定

尝试从Nave的解决方案修改树（以原始树对象格式输出结果，将property设置为display=false以隐藏节点，即使找到匹配节点，也继续搜索同一级别的其他节点）。 这似乎是一个DFS，但我仍然需要很多时间来计算回溯。最终结果是返回只包含匹配结果及其父/祖先的树

searchHelper(term, children, showParent) {
    let found;
    if (showParent == null || showParent == undefined) {
        showParent = false;
    }
    children.forEach(child => {
        if (found = this.search(term, child)){
            console.log('found--------------------------------');
            child.display = true;
        } else {
            console.log('not foond-----------------------------------------')
            child.display = false;
        }
        showParent = showParent || found;
    })
    return showParent;
}

search(term, parent) {
    let ans, showParent, found, { name, children } = parent;

    if (children.length) {
        showParent = this.searchHelper(term, children, showParent);
    }
    return name.toLowerCase().indexOf(term.toLowerCase()) != -1;
}

this.search("Elephant", this.tree);

---

我想这就是你想要的：

search = node => {
    let found, { name, childs = [] } = node;

    if (childs.length)
        for (let child of node.childs)
            if (found = search(child))
                return [name].concat(found);

    return name === target && [name];
}

以下是我的完整解决方案：

const
//你的动物目标名称
目标='大象'，
//您的树数据结构
树=[
{姓名：'大象'，孩子们：[
{name:'Duck'}，
{名字：'仓鼠'，孩子们：[
{name:'Fish'}
]}
]},
{名字：'仓鼠'，孩子们：[
{姓名：'大象'，孩子们：[
{name:'Fish'}
]},
{名字：'狗'，孩子们：[
{name:'Fish'}
]}
]},
{名字：'狗'，孩子们：[
{名称：'独角兽'}，
{名字：'鱼'，孩子们：[
{name:'仓鼠'}，
{姓名：'独角兽'，儿童：[
{名称：'大象'}
]},
]}
]},
{姓名：'大象'，孩子们：[
{name:'Duck'}，
{名字：'仓鼠'，孩子们：[
{名称：'大象'}，
{名字：'鱼'}，
]}
]}
],
//递归树搜索函数。她的出发点是
//与目标匹配的孩子。他回到了通往天堂的道路上
//目标-如果找到-作为数组。否则，错误
搜索=节点=>{
让我们找到，{name，childs=[]}=node；
if（儿童长度）
for（让node.childs的子级）
如果（找到=搜索（子项））
返回[name].concat（已找到）；
返回名称===target&&[name]；
},
//结果，作为一组数组。我们过滤掉了
//不包含结果的分支
结果=tree.map（搜索）.filter（布尔值）；
//结果以格式化字符串的形式显示，便于查看
formattedResult=result.map（（路径，索引）=>`${index+1}:${path.join（'>'）}`）。join（'\n'）；
console.log（格式化结果）

Hi是否有可能以树格式返回类似对象的答案？i、 回答像{name:'大象'，childs:[]}，{name:'仓鼠'，childs:[{name:'大象'，childs:[]}，….我感谢你的帮助。不知道孩子是否有2个“大象”，一旦找到第一个“大象”，它就不能从函数返回，而是继续搜索其他孩子。（请参见问题中我编辑的数组）。谢谢

search = node => {
    let found, { name, childs = [] } = node;

    if (childs.length)
        for (let child of node.childs)
            if (found = search(child))
                return [name].concat(found);

    return name === target && [name];
}