打平的数组换成树形数组:输入:[ ( id: 1, parentld:null} ,( id: 2, parentid:1},{id:3,parentid:2}]输出:[ ( id: 1, children:} ,( id: 2, children:[{id:3,2}]
时间: 2023-06-04 15:08:45 浏览: 52
抱歉,我可以回答这个问题。可以通过以下方法将打平的数组转换为树形数组:
```
function generateTree(arr, parentid) {
var tree = [];
for(var i=0; i<arr.length; i++) {
if(arr[i].parentid === parentid) {
var node = {
id: arr[i].id,
children: generateTree(arr, arr[i].id)
};
tree.push(node);
}
}
return tree;
}
var arr = [
{id: 1, parentid: null},
{id: 2, parentid: 1},
{id: 3, parentid: 2}
];
generateTree(arr, null);
```
输出结果为:
```
[
{
id: 1,
children: [
{
id: 2,
children: [
{
id: 3,
children: []
}
]
}
]
}
]
```
相关问题
js二维数组转换树形结构
以下是将js二维数组转换为树形结构的示例代码:
```javascript
function convertToTree(arr) {
const map = {};
const roots = [];
for (let i = 0; i < arr.length; i++) {
const node = arr[i];
const id = node[0];
const parentId = node[1];
if (!map[id]) {
map[id] = {
id: id,
children: []
};
}
map[id].name = node[2];
if (!parentId) {
roots.push(map[id]);
} else {
if (!map[parentId]) {
map[parentId] = {
id: parentId,
children: []
};
}
map[parentId].children.push(map[id]);
}
}
return roots;
}
const arr = [
[1, null, 'A'],
[2, 1, 'B'],
[3, 1, 'C'],
[4, 2, 'D'],
[5, 2, 'E'],
[6, 3, 'F'],
[7, 3, 'G']
];
const tree = convertToTree(arr);
console.log(tree);
```
在上面的代码中,我们首先创建了一个空的对象`map`和一个空的数组`roots`,`map`用于存储每个节点的引用,`roots`用于存储根节点。
然后我们遍历`arr`,对于每个节点,我们首先通过节点的`id`创建一个对象,然后将节点的`name`赋值给该对象的`name`属性。如果该节点没有父节点,则将该节点添加到`roots`数组中。否则,我们查找该节点的父节点是否已经在`map`中存在,如果不存在,则创建一个空的对象,并将其添加到`map`中。然后将该节点添加到父节点的`children`数组中。
最后,我们返回`roots`数组,它包含了整棵树的根节点。
js数组转多层树形结构
在JavaScript中,将一个数组转换为多层树形结构可以通过递归和遍历来实现。以下是一个基本的实现思路:
1. 定义一个函数,接收一个数组作为参数,返回一个多层树形结构的对象。
2. 创建一个空对象,用于存储树的结构。
3. 遍历数组,对于每个元素,判断其是否有父节点。如果有父节点,则将当前元素添加到父节点的children属性中,同时将当前元素作为子节点的父节点。
4. 如果没有父节点,则将当前元素作为根节点添加到树的结构中。
5. 通过递归调用函数,将子节点作为参数传递给函数,继续构建子节点的子节点,直到没有子节点为止。
6. 返回构建好的多层树形结构对象。
下面是一个简单的示例代码:
```
function arrayToTree(arr) {
let tree = {}; // 存储树的结构
// 递归构建树的函数
function buildTree(nodes, parentId) {
let result = [];
for (let i = 0; i < nodes.length; i++) {
if (nodes[i].parentId === parentId) { // 判断当前节点的父ID是否匹配
let node = Object.assign({}, nodes[i]); // 复制当前节点
node.children = buildTree(nodes, node.id); // 构建当前节点的子节点
result.push(node);
}
}
return result;
}
tree = buildTree(arr, null); // 构建多层树形结构
return tree;
}
// 测试
let arr = [
{ id: 1, parentId: null, name: 'A' },
{ id: 2, parentId: 1, name: 'B' },
{ id: 3, parentId: 1, name: 'C' },
{ id: 4, parentId: 2, name: 'D' },
{ id: 5, parentId: 2, name: 'E' }
];
console.log(arrayToTree(arr));
```
以上代码会将数组`arr`转换为以下多层树形结构对象:
```
{
id: 1,
parentId: null,
name: 'A',
children: [
{
id: 2,
parentId: 1,
name: 'B',
children: [
{ id: 4, parentId: 2, name: 'D', children: [] },
{ id: 5, parentId: 2, name: 'E', children: [] }
]
},
{
id: 3,
parentId: 1,
name: 'C',
children: []
}
]
}
```
注意:以上示例代码仅演示了基本的思路和过程,实际情况下可能需要根据具体的业务需求进行适当的修改和调整。