用js写一个递归方法，遍历一个tree结构数组，找到与输入id相同的节点并返回

好的，以下是一个递归方法的示例代码，可以遍历一个tree结构数组，找到与输入id相同的节点并返回：

function findNodeById(tree, id) {
  for (let node of tree) {
    if (node.id === id) {
      return node;
    }
    if (node.children) {
      let result = findNodeById(node.children, id);
      if (result) {
        return result;
      }
    }
  }
  return null;
}

这个方法接收两个参数，第一个参数是要遍历的tree结构数组，第二个参数是要查找的id。首先，它会遍历当前层级的每一个节点，如果找到了与输入id相同的节点，就直接返回这个节点。如果当前节点有子节点，就递归调用自己，传入子节点的数组和要查找的id，直到遍历到最底层的节点为止。如果遍历完了整个树都没有找到与输入id相同的节点，就返回null。

相关问题

一个tree结构多级嵌套的数组，根据id找到tree中对应的数据及其所有父节点，然后组成一个数组

可以使用递归来实现这个功能，具体步骤如下：

1. 定义一个函数，传入两个参数：数组和要查找的id。

2. 遍历数组，找到id对应的元素。

3. 如果找到了，将该元素添加到结果数组中。

4. 如果该元素有父节点，递归调用函数，并将父节点作为要查找的id传入。

5. 将返回的结果数组合并到当前结果数组中。

6. 返回结果数组。

代码如下：

function findItemById(arr, id) {
  let result = [];
  for (let i = 0; i < arr.length; i++) {
    if (arr[i].id === id) {
      result.push(arr[i]);
      if (arr[i].parentId) {
        let parentArr = findItemById(arr, arr[i].parentId);
        result = [...result, ...parentArr];
      }
      break;
    }
    if (arr[i].children && arr[i].children.length) {
      let childArr = findItemById(arr[i].children, id);
      if (childArr.length) {
        result.push(arr[i]);
        result = [...result, ...childArr];
        break;
      }
    }
  }
  return result;
}

这个函数可以处理多级嵌套的tree结构数组，可以根据id查找到对应的元素及其所有父节点，并将结果组成一个数组返回。

用 js 写数组转树递归方法

### 回答1：
可以使用以下代码实现：

function arrayToTree(arr, id = 'id', pid = 'parentId', children = 'children') {
let map = {};
let res = [];
for (let i = ; i < arr.length; i++) {
map[arr[i][id]] = arr[i];
arr[i][children] = [];
}
for (let i = ; i < arr.length; i++) {
let item = arr[i];
let parent = map[item[pid]];
if (parent) {
parent[children].push(item);
} else {
res.push(item);
}
}
return res;
}

### 回答2：
数组转树的递归方法可以通过 JavaScript 来实现。具体步骤如下：

1. 创建一个空对象作为树的根节点。
2. 遍历数组中的每个元素，将每个元素插入到树中适当的位置。
3. 在插入元素时，首先需要根据元素的父节点找到对应的树节点。
4. 如果元素的父节点是根节点，则直接将元素插入到根节点的子节点数组中。
5. 如果元素的父节点不是根节点，则需要在当前树中递归查找该父节点，并将元素插入到父节点的子节点数组中。
6. 返回树的根节点。

下面是使用 JavaScript 实现数组转树递归方法的示例代码：

function arrayToTree(arr) {
  const tree = {}; // 创建树的根节点

  arr.forEach(item => {
    const { id, parentId } = item;
  
    if (parentId === null || parentId === undefined) {
      // 如果元素的父节点是根节点，则直接插入到子节点数组中
      if (!tree.children) {
        tree.children = [];
      }
      tree.children.push(item);
    } else {
      // 如果元素的父节点不是根节点，则递归查找父节点并插入到子节点数组中
      findParentAndInsert(tree, item);
    }
  });

  return tree;
}

function findParentAndInsert(node, item) {
  if (node.children) {
    const found = node.children.find(child => child.id === item.parentId);
    if (found) {
      if (!found.children) {
        found.children = [];
      }
      found.children.push(item);
    } else {
      node.children.forEach(child => findParentAndInsert(child, item));
    }
  }
}

上述代码定义了一个 `arrayToTree` 的函数，用于将数组转换成树。传入的数组 `arr` 包含了要转换的元素，每个元素具有 `id` 和 `parentId` 属性，分别表示元素的唯一标识和父节点的标识。函数返回一个具有树结构的对象。

### 回答3：
JS写数组转树的递归方法可以按照以下步骤实现：

1. 创建一个空的树对象，用来存储转换后的树形结构。
2. 遍历数组，将每个元素添加到树中的适当位置。
3. 对于每个元素，将其根据指定的父子关系逐级添加到树中。
4. 如果一个元素的父级id为空或不存在，那么它就是树的根节点，将其添加到树对象中。
5. 如果一个元素的父级id存在于树中，则将其添加为该父级的子节点。
6. 重复上述步骤，直到遍历完所有元素。
7. 返回转换后的树对象。

以下是一个示例的JS代码，用于将数组转换为树的递归方法：

function arrayToTree(array) {
  const tree = {};

  function addToTree(parentId, item) {
    if (!tree[parentId]) {
      tree[parentId] = {};
    }
    tree[parentId][item.id] = item;

    if (item.children && item.children.length > 0) {
      item.children.forEach(child => {
        addToTree(item.id, child);
      });
    }
  }

  array.forEach(item => {
    if (!item.parentId || !tree[item.parentId]) {
      tree[item.id] = item;
    } else {
      addToTree(item.parentId, item);
    }
  });

  return tree;
}

// 示例用法
const array = [
  { id: 1, parentId: null },
  { id: 2, parentId: 1 },
  { id: 3, parentId: 1 },
  { id: 4, parentId: 2 },
  { id: 5, parentId: 3 }
];

const tree = arrayToTree(array);
console.log(tree);

以上代码将会输出一个包含转换后树形结构的对象。