JavaScript非二叉树节点深度计算指南

class Node {
    constructor(name, ...children) {
        this.name = name;
        this.children = children; // children是一个数组，可以包含任意数量的子节点
    }

    /**
     * 从当前节点开始，向下搜索指定名称的节点，并返回其深度。
     * 如果当前节点就是目标节点，深度为0。
     * 如果未找到，返回-1。
     * @param {string} targetName - 目标节点的名称
     * @returns {number} - 目标节点的深度，如果未找到则为-1
     */
    getDepth(targetName) {
        // 基线条件1：如果当前节点就是目标节点，其深度为0
        if (this.name === targetName) {
            return 0;
        }

        // 递归步骤：遍历所有子节点
        for (const child of this.children) {
            // 递归调用子节点的getDepth方法
            const depthInChildSubtree = child.getDepth(targetName);

            // 如果在子树中找到了目标节点（返回值 >= 0）
            if (depthInChildSubtree >= 0) {
                // 目标节点的深度是子树深度加1
                return depthInChildSubtree + 1;
            }
        }

        // 基线条件2：遍历完所有子节点仍未找到，返回-1
        return -1; 
    }
}

// 构建示例树结构
const root = new Node("root",
    new Node("A",
        new Node("C",
            new Node("G"),
            new Node("H"),
            new Node("I")
        ),
        new Node("D")
    ),
    new Node("B",
        new Node("E"),
        new Node("F")
    )
);

// 示例调用：计算节点"C"的深度
const depthOfC = root.getDepth("C");
console.log(`节点 "C" 的深度: ${depthOfC}`); // 预期输出: 2

// 示例调用：计算节点"G"的深度
const depthOfG = root.getDepth("G");
console.log(`节点 "G" 的深度: ${depthOfG}`); // 预期输出: 3

// 示例调用：计算不存在的节点"X"的深度
const depthOfX = root.getDepth("X");
console.log(`节点 "X" 的深度: ${depthOfX}`); // 预期输出: -1

class Node {
    constructor(name, ...children) {
        this.name = name;
        this.children = children;
    }

    /**
     * 计算当前节点相对于给定根节点的深度。
     * 如果当前节点就是根节点，深度为0。
     * 如果当前节点不在以给定根节点为起点的树中，返回-1。
     * @param {Node} root - 树的根节点
     * @returns {number} - 当前节点的深度，如果未找到则为-1
     */
    getDepthWithRespectTo(root) {
        // 基线条件1：如果当前节点就是传入的根节点，深度为0
        if (this === root) {
            return 0;
        }

        // 递归步骤：在根节点的子节点中查找当前节点
        for (const child of root.children) {
            // 递归调用，尝试在child为根的子树中找到当前节点
            const depth = this.getDepthWithRespectTo(child);

            // 如果在子树中找到了当前节点（返回值 >= 0）
            if (depth >= 0) {
                // 当前节点的深度是子树深度加1
                return depth + 1;
            }
        }

        // 基线条件2：遍历完所有子节点仍未找到，返回-1
        return -1;
    }
}

// 构建示例树结构，并保留对节点"C"的引用
let nodeC; // 用于保存对节点C的引用
const root = new Node("root",
    new Node("A",
        nodeC = new Node("C", // 节点C被赋值给nodeC
            new Node("G"),
            new Node("H"),
            new Node("I")
        ),
        new Node("D")
    ),
    new Node("B",
        new Node("E"),
        new Node("F")
    )
);

// 示例调用：计算节点"C"相对于根节点的深度
const depthOfC_alt = nodeC.getDepthWithRespectTo(root);
console.log(`节点 "C" 的深度 (方案二): ${depthOfC_alt}`); // 预期输出: 2

// 假设我们有一个不在树中的节点
const nodeX = new Node("X");
const depthOfX_alt = nodeX.getDepthWithRespectTo(root);
console.log(`节点 "X" 的深度 (方案二): ${depthOfX_alt}`); // 预期输出: -1