在根和任何对象之间的对象树中查找对象

Question

我有一个典型的树数据结构，如下所示：

[
  {
    data: object,
    subs:
      [ ...other objects... ]
  },
  ...other objects...
]

它可以有任何形状和数量的节点。

我写了一个方法，它应该递归地找到并返回根 r 和给定对象 o 之间的路径（中间对象数组）。 （无论是否包括 r 和 o 我都不在乎）

public getPath(tree: Array<object>, o: object): Array<object> {

  let path: Array<object> = [];

  function f(subtree: Array<object>): void {
    for (let node of subtree) {

      path.push(node['data']);
      if (node['data'] == o) return;
      else if (node['subs'].length > 0) f(node['subs']);
      else path = [];

    }
  }

  f(tree);
  return path;

}

基本上我的想法是

• 始终将每个对象添加到从 r 到 o 的遍历期间访问的数组中，
• 如果遍历的路径不是从 r 到 o 的路径，则清空数组，
• 如果到达 o 则返回应该结束遍历的位置。

结果：

• 它适用于 r 作为 o，返回 [r]。
• 它也适用于 r 作为 o 的第一个孩子，返回 [r，r 的第一个孩子强>]。
• 但是对于选择任何其他对象作为o，不仅返回正确路径的对象，还返回树的许多其他对象。

Answer 1

您的代码的缺陷是您使用的是全局（无论如何都超出了f 的范围）path 数组。问题是如果节点不匹配，您将清除整个数组，而您应该只删除当前部分。有两种方法可以实现您想要的：首先是让f 接受一个数组path，它会复制并递归传递直到找到对象，另一种最好的方法是利用调用栈（由递归创建）：

public getPath(tree: Array<object>, o: object): Array<object> {

    function f(subtree: Array<object>) {                              // I don't know typescript, so specify the return type as (Array<object> or null)
        for (let node of subtree) {
            if (node.data == o) {                                     // if this is the node we're looking for
                return [node];                                        // return an array (which will be our path), here you can either return [] to exclude the matched node (o) or [node] to include it
            } else if(node.subs.length) {                             // not the node we are looking for, but it has children, so let check'em out 
                let result = f(node.subs);                            // result will either be an array (if we recursively found something), or null otherwise
                if(result) {                                          // if we found something, then result will be the path from the current node to the object o (the current node not included)
                    result.unshift(node);                             // we include the current node by pushing it into the result array (pushing it to the first position)
                    return result;                                    // return result (an array) to signal successfulness
                }
            }
        }
        return null;                                                  // the object o not found in this subtree, return null to signal unsuccessfullness. Kind of redundant, because undefined is returned by default, so feel free to remove it
    }

    return f(tree);    
}