数组[]，树tree相互转换

列表转树：

let arr = [
    {id: 1, name: '部门1', pid: 0},
    {id: 2, name: '部门2', pid: 1},
    {id: 3, name: '部门3', pid: 1},
    {id: 4, name: '部门4', pid: 3},
    {id: 5, name: '部门5', pid: 4},
]// 初始数据

递归方法：

/**
 * 递归查找，获取children
 */
const getChildren = (data, result, pid) => {
  for (const item of data) {
    if (item.pid === pid) {
      const newItem = {...item, children: []};
      result.push(newItem);
      getChildren(data, newItem.children, item.id);
    }
  }
}

/**
* 转换方法
*/
const arrayToTree = (data, pid) => {
  const result = [];
  getChildren(data, result, pid)
  return result;
}

时间复杂度为O(2^n)

Map方法：先把数据转成Map去存储，之后遍历的同时借助对象的引用，直接从Map找对应的数据做存储

function arrayToTree(items) {
  const result = [];   // 存放结果集
  const itemMap = {};  // map集
    
  // 先转成map存储
  for (const item of items) {
    itemMap[item.id] = {...item, children: []}
  }
  
  for (const item of items) {
    const {id,pid} = item;// 遍历的id,pid
    const treeItem =  itemMap[id];// id对应的map集数据
    if (pid === 0) {
      result.push(treeItem);// 首个节点
    } else {
      if (!itemMap[pid]) {// 如果pid对应的map集合不存在
        itemMap[pid] = { children: [] }//  将此对象添加child
      }
      itemMap[pid].children.push(treeItem)// pid对应的map集添加子节点treeItem
    }
  }
  return result;
}

有两次循环，该实现的时间复杂度为O(2n)，需要一个Map把数据存储起来，空间复杂度O(n)

把数据转成Map去存储，之后遍历的同时借助对象的引用，直接从Map找对应的数据做存储。不同点在遍历的时候即做Map存储,有找对应关系。

function arrayToTree(items) {
  const result = [];   // 存放结果集
  const itemMap = {};  // map集
  for (const item of items) {
   const {id,pid} = item;// 遍历的id,pid
    if (!itemMap[id]) {// 如果map数据对应的id的数据不存在，设置children
      itemMap[id] = {
        children: [],
      }
    }
  // 根据id设置map数据集的children
    itemMap[id] = {
      ...item,
      children: itemMap[id]['children']
    }

    const treeItem =  itemMap[id];// 取出map中id对应的数据

    if (pid === 0) {
      result.push(treeItem);// 首个节点
    } else {
      if (!itemMap[pid]) {// 如果pid对应的map没有，设置child为[]
        itemMap[pid] = {
          children: [],
        }
      }
      itemMap[pid].children.push(treeItem)// 设置map的children组成树结构
    }

  }
  return result;// 返回树
}

该实现的时间复杂度为O(n)，需要一个Map把数据存储起来，空间复杂度O(n)