JavaScript中计算通用树节点深度的递归方法

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

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

        // 递归遍历子节点
        for (const child of this.children) {
            const depth = child.getDepth(targetName); // 递归调用
            // 如果子节点找到了目标（depth >= 0），则当前节点的深度是子节点深度 + 1
            if (depth >= 0) {
                return depth + 1;
            }
        }

        // 终止条件2：遍历完所有子节点仍未找到
        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")
    )
);

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

const depthOfG = root.getDepth("G");
console.log(`节点G的深度: ${depthOfG}`); // 输出: 节点G的深度: 3

const depthOfNonExistent = root.getDepth("X");
console.log(`节点X的深度: ${depthOfNonExistent}`); // 输出: 节点X的深度: -1

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

    /**
     * 计算当前节点相对于指定根节点的深度。
     * 如果当前节点就是根节点，深度为0。
     * 如果未找到当前节点在根节点下的位置，返回-1。
     * @param {Node} rootNode - 作为参考的根节点实例。
     * @returns {number} 当前节点相对于rootNode的深度。
     */
    getDepthWithRespectTo(rootNode) {
        // 终止条件1：如果当前节点就是根节点
        if (this === rootNode) {
            return 0;
        }

        // 遍历根节点的子节点，寻找当前节点
        for (const child of rootNode.children) {
            // 递归地在子节点上调用此方法，寻找当前节点
            // 注意：这里是 `this` (目标节点) 在 `child` 子树中寻找 `this` 自身相对于 `child` 的深度
            const depth = this.getDepthWithRespectTo(child);
            // 如果在子节点下找到了当前节点（depth >= 0）
            if (depth >= 0) {
                return depth + 1; // 深度加1
            }
        }

        // 终止条件2：遍历完所有子节点仍未找到
        return -1; // 表示未找到
    }
}

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

// 调用示例
const depthOfC_v2 = nodeC.getDepthWithRespectTo(root);
console.log(`节点C相对于根节点的深度: ${depthOfC_v2}`); // 输出: 节点C相对于根节点的深度: 2

// 假设我们有一个不在树中的节点
const nodeX = new Node("X");
const depthOfX_v2 = nodeX.getDepthWithRespectTo(root);
console.log(`节点X相对于根节点的深度: ${depthOfX_v2}`); // 输出: 节点X相对于根节点的深度: -1