如何计算树形结构对象中嵌套children数组的最大层级？

我需要计算如下树形结构对象中嵌套children数组的最大层级：

let node = {
    age: 23,
    name: "christian",
    children: [{
        age: 25,
        name: "michael",
        children: [{
            age: 33,
            name: "Johann",
            children: [{
                age: 45,
                name: "Christiaaann",
            }]
        }]
    }, {
        age: 90,
        name: "Monika",
        children: [{
            age: 10,
            name: "WHATEVER",
        }]
    }]
};

其中第一个子树的层级为3（包含3层嵌套children数组），右侧子树层级为2（包含2层嵌套children数组）。

我想用递归方案解决，知道要统计每个子树层级并比较最大值，但不清楚递归调用中该在哪里进行计数累加，以下是我目前的代码：

let node = {
    age: 23,
    name: "christian",
    children: [{
        age: 25,
        name: "michael",
        children: [{
            age: 33,
            name: "Johann",
            children: [{
                age: 45,
                name: "Christiaaann",
            }]
        }]
    }, {
        age: 90,
        name: "Monika",
        children: [{
            age: 10,
            name: "WHATEVER",
        }]
    }]
};

let level_count;
let max_count = 0;

function level_counter(obj, func) {
    level_count = 0;
    func(obj);
    console.log("INSIDEFUNCTION", level_count);


    if (obj.children) {
        level_count++;
        obj.children.forEach(function(child) {
            console.log(child);
            level_counter(child, func);


        });
        if (level_count > max_count) {
            max_count = level_count;
        }
    }
}

function tree_get_levels(root) {
    level_counter(root, function(obj) { });
    console.log("DOWNONE", level_count);
    return 0;
}

let result = tree_get_levels(node);
console.log(result);

解决思路与修正代码 #

你的代码核心问题在于全局变量level_count和max_count的逻辑混乱，递归时每次都会重置level_count，导致计数被覆盖，无法正确跟踪每个子树的层级。递归的正确逻辑应该是每个节点的嵌套层级 = 1 + 其子节点的最大嵌套层级，没有子节点的节点层级为0。

下面是修正后的递归实现：

function getMaxChildrenLevel(node) {
    // 终止条件：没有children或children为空，返回0（无嵌套层级）
    if (!node.children || node.children.length === 0) {
        return 0;
    }
    // 遍历所有子节点，获取每个子树的最大嵌套层级
    const childLevels = node.children.map(child => getMaxChildrenLevel(child));
    // 当前节点的嵌套层级 = 1（自身的children层） + 子节点的最大层级
    return 1 + Math.max(...childLevels);
}

// 测试调用
console.log(getMaxChildrenLevel(node)); // 输出3，符合预期

逻辑说明 #

• 递归终止：当节点没有children或者children为空时，说明这一层没有嵌套的子节点，返回0。
• 递归计算：对于有children的节点，遍历每个子节点并递归调用函数，得到每个子树的最大嵌套层级。
• 层级累加：当前节点的嵌套层级是自身的1层，加上所有子节点中的最大层级，最终向上传递得到整个树的最大嵌套层级。

对比原代码的改进 #

原代码依赖全局变量共享状态，容易出现计数被覆盖的问题。改用递归返回值的方式，每个递归调用独立计算自身子树的层级，逻辑更清晰，也避免了全局变量的副作用。

内容的提问来源于stack exchange，提问作者Aalexander