Создание вложенного массива TreeNode в Typescript

Question

Учитывая плоский одномерный массив типа 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, treeNode4, ..., treeNodeX]

Выходными данными является объект TreeNode, вложенный в свойство children (которое также имеет тип TreeNode):

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

Я понимаюне умеют динамически вызывать treeNode1.children [0] .children [0] ...... children [0] для числа X детей в цикле, чтобы назначить следующий уровень потомков в treeNode1.

Answer 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 = [];
}

Надеюсь, это поможет.

Answer 2

Я построил алгоритм для вас.Я построил его в простом javascript, но он должен легко модифицироваться, чтобы соответствовать вашему интерфейсу машинописи.

И код здесь:

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": []
                                }
                            ]
                        }
                    ]
                }
            ]
        }
    ]
}