在 Typescript 中构建嵌套的 TreeNode 数组答案

【问题标题】：Building nested TreeNode array in Typescript在 Typescript 中构建嵌套的 TreeNode 数组
【发布时间】：2019-07-06 08:55:27
【问题描述】：

给定一个 TreeNode 类型的平面一维数组（参见下面的接口定义），我想遍历该数组并将后续数组元素添加为子元素。

递归做会很棒，我在非递归中使用缓冲区，但我面临的问题是如何做node.children[0].children[0]...children[0]，因为请注意每个父母只有一个孩子。

    Childify(results: TreeNode[]): any {
    var node: TreeNode;
    var buffer: TreeNode;
    var count: number = 0;

    for (var res of results) {
        if (count == 0) {
            node = res[0];
            buffer = res[0];
            buffer.children = [];
            node.children = [];
        } else if (count == 1) {
            buffer.children = res[0];
        } else {
            node = buffer;
            node.children = [];
            node.children.push(res[0]);
            buffer = <TreeNode>node.children;
        }

        count++;
    }
}

接口定义：

export interface TreeNode {
label?: string;
data?: any;
icon?: any;
expandedIcon?: any;
collapsedIcon?: any;
children?: TreeNode[];  <---------------
leaf?: boolean;
expanded?: boolean;
type?: string;
parent?: TreeNode;
partialSelected?: boolean;
styleClass?: string;
draggable?: boolean;
droppable?: boolean;
selectable?: boolean;

}

输入：

TreeNode[] = [treeNode1, treeNode2, treeNode3, 树节点4,...,树节点X]

输出是一个 TreeNode 对象，嵌套在 children 属性中（也是 TreeNode 类型）：

TreeNode = treeNode1
treeNode1.children = treeNode2
treeNode2.children = treeNode3
treeNode3.children = treeNode4
treeNodeX-1.children = treeNodeX

我不知道如何为循环中的 X 个孩子动态调用 treeNode1.children[0].children[0]......children[0]，以分配给下一级孩子在树节点 1 中。

【问题讨论】：

基于什么插入节点？您希望生成的三个看起来如何？

标签： arrays typescript recursion primeng

【解决方案1】：

我不知道 TypeScript，但这是我在 JavaScript 中的做法：

const input = [ new TreeNode("node1")
              , new TreeNode("node2")
              , new TreeNode("node3")
              , new TreeNode("node4")
              , new TreeNode("node5")
              ];

const output = input.reduceRight((child, parent) => {
    parent.children.push(child);
    return parent;
});

console.log(output);

function TreeNode(name) {
    this.name = name;
    this.children = [];
}

希望对您有所帮助。

【讨论】：

【解决方案2】：

我已经为你构建了一个算法。我用简单的 javascript 构建了它，但它应该很容易修改以符合您的 typescript 界面。

代码在这里：

var flatNodes = [
    {
        name: 'node1',
        children: []
    },
    {
        name: 'node2',
        children: []
    },
    {
        name: 'node3',
        children: []
    },
    {
        name: 'node4',
        children: []
    },
    {
        name: 'node5',
        children: []
    }
];

function linkNodes(flatNodes) {
    flatNodes = flatNodes.slice(); //copy the list

    flatNodes = flatNodes.reverse();

    for (var i = 1; i < flatNodes.length; i++) {
        var previousNode = flatNodes[i - 1];
        var currentNode = flatNodes[i];

        currentNode.children.push(previousNode);
    }

    return flatNodes[flatNodes.length - 1];
}

console.log(linkNodes(flatNodes));

输出在这里：

{
    "name": "node1",
    "children": [
        {
            "name": "node2",
            "children": [
                {
                    "name": "node3",
                    "children": [
                        {
                            "name": "node4",
                            "children": [
                                {
                                    "name": "node5",
                                    "children": []
                                }
                            ]
                        }
                    ]
                }
            ]
        }
    ]
}

【讨论】：