树形数组对象扁平化与反向转换

将树形数组对象扁平化是将具有层级结构的对象数组转换成一个简单的、没有嵌套的对象数组的过程。这通常涉及到递归遍历树结构，并将每个节点添加到一个新的数组中。下面是一个使用JavaScript实现这一过程的例子：

function flattenTree(tree) {  
    let result = [];  
  
    function traverse(node) {  
        result.push(node); // 将当前节点添加到结果数组中  
        if (node.children) {  
            // 如果当前节点有子节点，递归遍历子节点  
            for (let child of node.children) {  
                traverse(child);  
            }  
        }  
    }  
  
    // 从树的根节点开始遍历  
    for (let node of tree) {  
        traverse(node);  
    }  
  
    return result;  
}  
  
// 假设我们有一个树形数组对象  
let treeArray = [  
    {  
        id: 1,  
        name: 'A',  
        children: [  
            {  
                id: 2,  
                name: 'B',  
                children: [  
                    { id: 4, name: 'D' },  
                    { id: 5, name: 'E' }  
                ]  
            },  
            {  
                id: 3,  
                name: 'C',  
                children: [  
                    { id: 6, name: 'F' }  
                ]  
            }  
        ]  
    }  
];  
  
// 扁平化树形数组对象  
let flatArray = flattenTree(treeArray);  
  
console.log(JSON.stringify(flatArray, null, 2));

运行这个函数后，flatArray 将会是一个扁平化的数组对象，如下所示：

[  
  {  
    "id": 1,  
    "name": "A"  
  },  
  {  
    "id": 2,  
    "name": "B"  
  },  
  {  
    "id": 4,  
    "name": "D"  
  },  
  {  
    "id": 5,  
    "name": "E"  
  },  
  {  
    "id": 3,  
    "name": "C"  
  },  
  {  
    "id": 6,  
    "name": "F"  
  }  
]

扁平化数组对象组装成树形数组对象

扁平化数组对象组装成树形数组对象是一个常见的编程问题。这通常涉及到将一组具有父子关系的对象转换成一个树形结构。以下是一个基本的步骤和示例，说明如何实现这一过程。

假设你有以下的扁平化数组对象（JavaScript格式）：

let flatArray = [  
    { id: 1, name: 'A', parent_id: null },  
    { id: 2, name: 'B', parent_id: 1 },  
    { id: 3, name: 'C', parent_id: 1 },  
    { id: 4, name: 'D', parent_id: 2 },  
    { id: 5, name: 'E', parent_id: 2 },  
    { id: 6, name: 'F', parent_id: 3 },  
];


function buildTree(items, parentId = null) {  
    let tree = [];  
    let children = [];  
  
    for (let i = 0; i < items.length; i++) {  
        if (items[i].parent_id === parentId) {  
            children = (buildTree(items, items[i].id);  
            if (children.length) {  
                items[i].children = children;  
            }  
            tree.push(items[i]);  
        }  
    }  
    return tree;  
}  
  
let treeArray = buildTree(flatArray);  
console.log(JSON.stringify(treeArray, null, 2));

运行这个函数后，treeArray将会是一个树形结构的数组对象，如下所示：

[  
  {  
    "id": 1,  
    "name": "A",  
    "parent_id": null,  
    "children": [  
      {  
        "id": 2,  
        "name": "B",  
        "parent_id": 1,  
        "children": [  
          {  
            "id": 4,  
            "name": "D",  
            "parent_id": 2  
          },  
          {  
            "id": 5,  
            "name": "E",  
            "parent_id": 2  
          }  
        ]  
      },  
      {  
        "id": 3,  
        "name": "C",  
        "parent_id": 1,  
        "children": [  
          {  
            "id": 6,  
            "name": "F",  
            "parent_id": 3  
          }  
        ]  
      }  
    ]  
  }  
]