Javascript 数组中的（子）元素计数

我有一个对象数组。每个对象如下所示：

{text: 'foo': level: N: children: M}

N

和

M

都是数字

N

表示对象的“深度”（将整个数组视为树的表示）

M

是该项具有的子项的总数。Total是指所有子级别的所有节点和叶的总和

我拥有的数组中的对象不包含

子对象

属性，我必须计算它

“计算”数据示例：

我可以很容易地对循环执行一次

，然后在项目上再迭代一次，从数组中的当前位置开始并计算子项（基于level属性），但我觉得这不是最好的方法（如“最快的”）

我还能怎么做呢

为了确保没有人发布比我目前拥有的“更糟糕”的代码，以下是我拥有的：

for (var i = 0; i < data.length; i++) {
    var item = data[i];

    for (var j = i + 1; j < data.length; j++) {
        if (item.level < data[j].level) {
            item.children++;
        } else {
            break;
        }
    }
}

for（变量i=0；i
在当前示例中，您根本无法计算子对象，因为您的数据不显示父对象/子对象关系<代码>级别：1

对于

文本：“C”

，例如，如果应该将其附加到

A

、

B

或

D

，则没有数据

---

如果您的意思是，但忘了提到子对象应该附加到最近提到的最接近的父对象，然后只需保留一个数组，其中每个条目将对应于该级别最后一次看到的父元素的引用，并在读取每一行新行后直接使用

+=

修改它的

children

属性。

在当前示例中，您根本无法计算子元素，因为您的数据没有显示父/子关系<代码>级别：1对于

文本：“C”

，例如，如果应该将其附加到

A

、

B

或

D

，则没有数据

---

如果您的意思是，但忘了提到子对象应该附加到最近提到的最接近的父对象，然后只需保留一个数组，其中每个条目将对应于该级别最后一次看到的父元素的引用，并在读取每一行新行后直接使用

+=

修改它的

children

属性。

我能想到的唯一方法是在不使用

for

循环的情况下执行此操作，需要您改革树结构JavaScript对象可以嵌套，因此我建议使用以下格式：

[
    {
        text: 'A',
        children: []
    },
    {
        text: 'B',
        children: 
        [
            {
                text: 'C',
                children: []
            }
        ]
     },
     {
         text: 'D',
         children:
         [
             {
                 text: 'E',
                 children:
                 [
                     {
                         text: 'F',
                         children: []
                     }
                 ]
             }
         ]
     }
]

然后，对于每个对象，“子对象总数”的公式如下：

function countChildren(obj) {
    var count = obj.children.length;
    for (int i = 0; i < children.length; i++) {
        count += countChildren(children[i]);
    }
    return count;
}

函数countChildren（obj）{
变量计数=obj.children.length；
for（int i=0；i

我能想到的唯一方法是在不使用

for

循环的情况下执行此操作，这需要您改革树结构JavaScript对象可以嵌套，因此我建议使用以下格式：

[
    {
        text: 'A',
        children: []
    },
    {
        text: 'B',
        children: 
        [
            {
                text: 'C',
                children: []
            }
        ]
     },
     {
         text: 'D',
         children:
         [
             {
                 text: 'E',
                 children:
                 [
                     {
                         text: 'F',
                         children: []
                     }
                 ]
             }
         ]
     }
]

然后，对于每个对象，“子对象总数”的公式如下：

function countChildren(obj) {
    var count = obj.children.length;
    for (int i = 0; i < children.length; i++) {
        count += countChildren(children[i]);
    }
    return count;
}

函数countChildren（obj）{
变量计数=obj.children.length；
for（int i=0；i

我认为@Oleg V.Volkov在他的评论中提出了这个答案。我认为这是一个很好的解决问题的方法&非常快，因为你只看了每个元素一次。然而，不利的一面是，由于父数组的存在，它在计算时可能会占用更多的内存

function countChildren(tree) {
    var currentParents = [];

    for (var i = 0; i < tree.length; i++) {
        // Initialize value of children
        tree[i].children = 0;

        if (i == 0) {
            continue;
        }

        // Find if the level increased, decreased, or stayed the same.
        var levelChange = tree[i].level - tree[i-1].level;

        // If level increased (by 1)
        if (levelChange == 1) {
            // Add previous element to list of parents
            currentParents.push(tree[i-1]);

        // If level decreased by 'x'
        } else if (levelChange < 0) {
            // Remove 'x' number of elements from the end of the list of parents
            for (var j = 0; j > levelChange; j--) {
                currentParents.pop();
            }
        }

        // Increase the number of children for all parents
        for (var j = 0; j < currentParents.length; j++) {
            currentParents[j].children++;
        }
    }
}

函数countChildren（树）{
var currentParents=[]；
对于（var i=0；ilevelChange；j--）{
currentParents.pop（）；
}
}
//增加所有家长的子女数量
对于（var j=0；j

我认为@Oleg V.Volkov在他的评论中提出了这个答案。我认为这是一个很好的解决问题的方法&非常快，因为你只看了每个元素一次。然而，不利的一面是，由于父数组的存在，它在计算时可能会占用更多的内存

function countChildren(tree) {
    var currentParents = [];

    for (var i = 0; i < tree.length; i++) {
        // Initialize value of children
        tree[i].children = 0;

        if (i == 0) {
            continue;
        }

        // Find if the level increased, decreased, or stayed the same.
        var levelChange = tree[i].level - tree[i-1].level;

        // If level increased (by 1)
        if (levelChange == 1) {
            // Add previous element to list of parents
            currentParents.push(tree[i-1]);

        // If level decreased by 'x'
        } else if (levelChange < 0) {
            // Remove 'x' number of elements from the end of the list of parents
            for (var j = 0; j > levelChange; j--) {
                currentParents.pop();
            }
        }

        // Increase the number of children for all parents
        for (var j = 0; j < currentParents.length; j++) {
            currentParents[j].children++;
        }
    }
}

函数countChildren（树）{
var currentParents=[]；
对于（var i=0；ilevelChange；j--）{