在JavaScript树形对象数组中查找子节点的根父节点

Hey there! Let's sort out why your recursive function isn't iterating over rootNode.children and fix that root node lookup issue.

The Likely Problem #

It sounds like you might have reversed the direction of your logic when adapting the tree-building code to find roots. If you're starting your recursion from the target child node (instead of the top-level root of the entire tree), its children array is probably empty (especially if it's a leaf node)—so the loop never runs. We need to start from the full tree's root and work our way down to find the target, then trace back to its top ancestor.

Solution 1: Recursive Lookup from the Tree Root (For Nested Tree Structures) #

Assuming your tree looks like this (nodes have id and children arrays, no direct parent references):

const tree = {
  id: 238,
  children: [
    {
      id: 239,
      children: [
        { id: 240, children: [] },
        { id: 241, children: [{ id: 242, children: [] }] }
      ]
    }
  ]
};

Here's a recursive function that starts at the root, traverses the tree, and returns the top-level root once it finds the target node:

function findRootFromNestedTree(tree, targetId, path = []) {
  // Track the path from root to current node
  const currentPath = [...path, tree];

  // If we've found the target, return the root (first item in the path)
  if (tree.id === targetId) {
    return currentPath[0];
  }

  // Recursively check each child if they exist
  if (tree.children && tree.children.length > 0) {
    for (const child of tree.children) {
      const result = findRootFromNestedTree(child, targetId, currentPath);
      // Return immediately if we find a match
      if (result) return result;
    }
  }

  // Target not found in this branch
  return null;
}

// Usage example
const rootNode = findRootFromNestedTree(tree, 242);
console.log(rootNode.id); // Outputs 238

Solution 2: Iterative Lookup (For Nodes with Parent References) #

If you added parent references when building your tree (each node points to its direct parent), this approach is faster and avoids recursion depth issues:

// Example node structure with parent references
const node242 = { id: 242, parent: node241 };
const node241 = { id: 241, parent: node239, children: [node242] };
const node239 = { id: 239, parent: node238, children: [node240, node241] };
const node238 = { id: 238, parent: null, children: [node239] };

function findRootFromParentReference(node) {
  let currentNode = node;
  // Keep moving up until we hit a node with no parent
  while (currentNode.parent != null) {
    currentNode = currentNode.parent;
  }
  return currentNode;
}

// Usage example
const rootNode = findRootFromParentReference(node242);
console.log(rootNode.id); // Outputs 238

Quick Checks for Your Original Code #

If you want to debug your existing code, verify these:

• Are you passing the full tree's root node to your recursive function, not the target child node?
• Does your root node actually have a children property (no typos like childs)?
• Is your recursive termination condition preventing the loop from running early?

内容的提问来源于stack exchange，提问作者Kapila Perera