JavaScript树节点深度计算：两种递归实现方法

class Node {
    constructor(name, ...children) {
        this.name = name;
        this.children = children;
    }
    // 后续方法将在此处添加
}

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

    /**
     * 从当前节点开始，按名称查找目标节点并返回其深度。
     * 如果当前节点就是目标节点，则深度为0。
     * 如果目标节点是当前节点的子孙，则深度为子节点深度+1。
     * 如果未找到，返回-1。
     * @param {string} targetName 目标节点的名称
     * @returns {number} 目标节点的深度，如果未找到则返回-1
     */
    getDepth(targetName) {
        // 基本情况：如果当前节点就是目标节点，其深度为0
        if (this.name === targetName) {
            return 0;
        }

        // 递归情况：遍历所有子节点
        for (const child of this.children) {
            // 递归调用子节点的getDepth方法
            const depth = child.getDepth(targetName);
            // 如果在子节点或其子孙中找到了目标节点
            if (depth >= 0) {
                // 返回子节点找到的深度加1（因为子节点比当前节点深一层）
                return depth + 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 depthC = root.getDepth("C");
console.log(`节点 "C" 的深度: ${depthC}`); // 预期输出: 2

// 测试计算节点"G"的深度
const depthG = root.getDepth("G");
console.log(`节点 "G" 的深度: ${depthG}`); // 预期输出: 3

// 测试计算根节点的深度
const depthRoot = root.getDepth("root");
console.log(`节点 "root" 的深度: ${depthRoot}`); // 预期输出: 0

// 测试查找不存在的节点
const depthX = root.getDepth("X");
console.log(`节点 "X" 的深度: ${depthX}`); // 预期输出: -1

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

    // ... (getDepth 方法可以保留或省略，取决于需求)

    /**
     * 计算当前节点相对于给定根节点的深度。
     * 如果当前节点就是根节点，则深度为0。
     * 否则，在根节点的子节点中查找路径，并递归计算深度。
     * 如果当前节点不是根节点的子孙，返回-1。
     * @param {Node} root 树的根节点
     * @returns {number} 当前节点的深度，如果不是根节点的子孙则返回-1
     */
    getDepthWithRespectTo(root) {
        // 基本情况：如果当前节点就是根节点，其深度为0
        if (this === root) {
            return 0;
        }

        // 递归情况：在根节点的子节点中查找
        // 注意：这里我们遍历的是root的子节点，而不是this的子节点
        for (const child of root.children) {
            // 递归调用子节点的getDepthWithRespectTo方法，
            // 检查当前节点是否是这个child的子孙
            const depth = this.getDepthWithRespectTo(child);
            // 如果在child的子孙中找到了当前节点
            if (depth >= 0) {
                // 返回子节点找到的深度加1（因为child比root深一层）
                return depth + 1;
            }
        }

        // 如果当前节点不是root或其任何子孙
        return -1;
    }
}

// 构建示例树，并保留节点"C"的引用
let nodeC; // 用于保存节点"C"的引用
const rootWithRef = 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"相对于rootWithRef的深度
const depthC_ref = nodeC.getDepthWithRespectTo(rootWithRef);
console.log(`节点 "C" 相对于根节点 "root" 的深度: ${depthC_ref}`); // 预期输出: 2

// 假设我们有一个节点G的引用 (需要手动获取或修改构建方式)
let nodeG;
rootWithRef.children[0].children[0].children[0] = nodeG = new Node("G"); // 重新赋值以获取引用
const depthG_ref = nodeG.getDepthWithRespectTo(rootWithRef);
console.log(`节点 "G" 相对于根节点 "root" 的深度: ${depthG_ref}`); // 预期输出: 3

// 测试计算根节点自身相对于自身的深度
const depthRoot_ref = rootWithRef.getDepthWithRespectTo(rootWithRef);
console.log(`节点 "root" 相对于根节点 "root" 的深度: ${depthRoot_ref}`); // 预期输出: 0

// 测试一个不在树中的节点（例如，一个全新的节点）
const newNode = new Node("NewNode");
const depthNewNode = newNode.getDepthWithRespectTo(rootWithRef);
console.log(`节点 "NewNode" 相对于根节点 "root" 的深度: ${depthNewNode}`); // 预期输出: -1