js树形数据常见笔试题

1. 如何将带有 id 和 parent_id 的扁平数据转换为树形结构

问题描述： 给定一个包含 id 和 parent_id 的扁平数据数组，如何将其转换为树形结构？

解答： 可以使用递归或迭代的方法来构建树形结构。以下是一个示例：

const data = [
  { id: 1, name: 'Node 1', parent_id: null },
  { id: 2, name: 'Node 1.1', parent_id: 1 },
  { id: 3, name: 'Node 1.1.1', parent_id: 2 },
  { id: 4, name: 'Node 1.1.2', parent_id: 2 },
  { id: 5, name: 'Node 1.2', parent_id: 1 },
  { id: 6, name: 'Node 2', parent_id: null },
  { id: 7, name: 'Node 2.1', parent_id: 6 }
];

function buildTree(data) {
  const tree = [];
  const childrenMap = {};

  data.forEach(item => {
    const { id, parent_id } = item;
    if (!childrenMap[id]) {
      childrenMap[id] = [];
    }
    item.children = childrenMap[id];

    if (parent_id === null) {
      tree.push(item);
    } else {
      if (!childrenMap[parent_id]) {
        childrenMap[parent_id] = [];
      }
      childrenMap[parent_id].push(item);
    }
  });

  return tree;
}

const treeData = buildTree(data);
console.log(JSON.stringify(treeData, null, 2));

2.如何获取某个节点的所有子节点？

问题描述： 给定一个树形结构数据，如何获取某个节点的所有子节点？

解答： 可以使用递归函数来获取所有子节点。以下是一个示例：

let treeData = [
  {
    "id": 1,
    "name": "Node 1",
    "parent_id": null,
    "children": [
      {
        "id": 2,
        "name": "Node 1.1",
        "parent_id": 1,
        "children": [
          {
            "id": 3,
            "name": "Node 1.1.1",
            "parent_id": 2,
            "children": []
          },
          {
            "id": 4,
            "name": "Node 1.1.2",
            "parent_id": 2,
            "children": []
          }
        ]
      },
      {
        "id": 5,
        "name": "Node 1.2",
        "parent_id": 1,
        "children": []
      }
    ]
  },
  {
    "id": 6,
    "name": "Node 2",
    "parent_id": null,
    "children": [
      {
        "id": 7,
        "name": "Node 2.1",
        "parent_id": 6,
        "children": []
      }
    ]
  }
]

function getAllChildren(node) {
  let children = [];
  if (node.children) {
    node.children.forEach(child => {
      children.push(child);
      children = children.concat(getAllChildren(child));
    });
  }
  return children;
}

// 示例用法
const node = treeData[0]; // 假设我们要获取第一个节点的所有子节点
const children = getAllChildren(node);
console.log(children);

3. 如何获取某个节点的所有父节点？

问题描述： 给定一个带有 id 和 parent_id 的扁平数据数组，如何获取某个节点的所有父节点？

解答： 可以使用递归函数来获取所有父节点。以下是一个示例：

function getAllParents(data, nodeId) {
  const parents = [];
  let currentNode = data.find(node => node.id === nodeId);

  while (currentNode && currentNode.parent_id !== null) {
    currentNode = data.find(node => node.id === currentNode.parent_id);
    if (currentNode) {
      parents.push(currentNode);
    }
  }

  return parents;
}

// 示例用法
const nodeId = 3; // 假设我们要获取 id 为 3 的节点的所有父节点
const parents = getAllParents(data, nodeId);
console.log(parents);

4. 如何在树形结构中查找某个节点？

问题描述： 给定一个树形结构数据，如何查找某个节点？

解答： 可以使用递归函数来查找节点。以下是一个示例：

function findNode(tree, nodeId) {
  for (const node of tree) {
    if (node.id === nodeId) {
      return node;
    }
    if (node.children) {
      const result = findNode(node.children, nodeId);
      if (result) {
        return result;
      }
    }
  }
  return null;
}

// 示例用法
const nodeId = 3; // 假设我们要查找 id 为 3 的节点
const node = findNode(treeData, nodeId);
console.log(node);

5. 如何计算树形结构的深度？

问题描述： 给定一个树形结构数据，如何计算树的深度？

解答： 可以使用递归函数来计算树的深度。以下是一个示例：

function getTreeDepth(node) {
  if (!node.children || node.children.length === 0) {
    return 1;
  }
  const depths = node.children.map(child => getTreeDepth(child));
  return 1 + Math.max(...depths);
}

// 示例用法
const depth = getTreeDepth(treeData[0]); // 假设我们要计算第一个节点的深度
console.log(depth);