// 第一种方法
// 定义一个单层数据结构
let data = [
    {
        id: 1,
        parentId: 0
    },
    {
        id: 2,
        parentId: 0
    },
    {
        id: 3,
        parentId: 1
    },
    {
        id: 4,
        parentId: 1
    },
    {
        id: 5,
        parentId: 2
    },
    {
        id: 6,
        parentId: 4
    }
];

// 定义一个函数，将单层数据结构转换为树结构
function convertToTree(data) {
    let tree = [];
    data.forEach(item => {
        let parentId = item.parentId;
        if (parentId === 0) {
            tree.push(item);
        } else {
            data.forEach(parentItem => {
                if (parentItem.id === parentId) {
                    if (parentItem.children) {
                        parentItem.children.push(item);
                    } else {
                        parentItem.children = [item];
                    }
                }
            });
        }
    });
    return tree;
}

// 调用函数，将单层数据结构转换为树结构
let tree = convertToTree(data);
console.log(tree);



//第二种方法

convertFun(data) {
      // 1.定义最外层的数组
      const tree = []
      // 2.定义一个空对象
      const otherObj = {}
      // 3.遍历数组内所有对象
      data.forEach(item => {
        // 3.1.给每个当前对象添加一个 children 属性, 以便存放子级对象
        item.children = []
        // 3.2 将当前对象的 id 作为键, 与当前对象自身形成键值对
        otherObj[item.id] = item
      })
      // 4.再次遍历数组内所有对象
      data.forEach(item => {
        // 4.1.判断每个当前对象的 parentId, 如当前对象 parentId不为空, 则说明不是上级的根对象
        if (item.parentId) {
          // 4.3.利用当前对象的 otherObj[parentId] 找到 otherObj[id] 中对应当前对象的父级对象, 将当前对象添加到其对应的父级对象的 children 属性中
          otherObj[item.parentId].children.push(item)
        } else {
          // 4.3.当前对象 parentId如果为空, 则为树状结构的根对象
          tree.push(item)
        }
      })

      tree.sort((a, b) => a.sortNumber - b.sortNumber)
      // 5.返回树状结构
      return tree
    },