理解树节点深度（层级）
在树形数据结构中，节点的“深度”（depth）或“层级”（level）是一个关键概念，它表示从根节点到当前节点的路径长度。通常，我们约定根节点的深度为0，其直接子节点的深度为1，以此类推。与二叉树不同，通用树的每个节点可以拥有任意数量的子节点，这使得其遍历逻辑更具普适性。本文的目标是为给定树中的特定节点，设计一个方法来准确计算其深度。
核心概念：递归遍历
由于树的天然递归结构，递归是解决节点深度计算问题的最直观和高效的方法。
- 递归原理: 一个节点的问题可以分解为其子节点相同问题的解决方案。
- 终止条件: 当我们找到目标节点时，或者当遍历到叶子节点（没有子节点的节点）仍未找到目标时，递归需要停止。
- 深度累加: 每向下深入一层，深度值就增加1。
方法一：从根节点向下搜索目标节点并计算深度
这种方法模拟了我们通常理解的“查找”过程：从树的顶部开始，逐层向下寻找目标节点。
思路分析:
- 从树的根节点开始调用计算深度的方法。
- 在当前节点，检查它是否就是我们要查找的目标节点。如果是，那么当前节点的深度就是0（相对于它自身而言）。
- 如果不是目标节点，则遍历当前节点的所有子节点。对每个子节点递归调用相同的深度计算方法。
- 如果某个子节点的递归调用成功找到了目标节点（返回了一个非负的深度值），那么当前节点相对于目标节点的深度就是该子节点返回的深度值加1。
- 如果所有子节点都遍历完毕，但都没有找到目标节点，则表示目标节点不在此分支下，返回一个表示“未找到”的值（例如-1）。
JavaScript实现示例 (按名称查找)
立即学习“Java免费学习笔记（深入）”；
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代码解释: getDepth(targetName) 方法在 Node 类中实现。它首先检查当前节点的 name 是否与 targetName 匹配。如果匹配，说明找到了目标，返回 0（因为这是目标节点自身）。如果不匹配，它会遍历 children 数组，对每个子节点递归调用 getDepth。如果任何一个子节点的递归调用返回了非负值（表示在其子树中找到了目标），那么当前节点到目标节点的深度就是该子节点返回的深度加 1。如果所有子节点都遍历完仍未找到，则返回 -1。
方法二：从目标节点视角计算其相对于根节点的深度
这种方法与第一种略有不同，它更符合“C.getLevel()”这种调用方式的语义，即从目标节点本身出发，询问其在整个树中的位置。然而，为了计算“相对于根节点”的深度，我们仍然需要传入根节点作为参照。
思路分析:
- 方法定义在目标节点上，但需要传入一个“参考根节点”。
- 如果当前节点（即调用方法的this）就是传入的参考根节点，那么它的深度就是0。
- 如果不是根节点，则需要检查根节点的所有直接子节点。对每个子节点，递归地询问“目标节点相对于这个子节点的深度是多少？”
- 如果某个子节点的递归调用成功返回了非负深度值，则说明目标节点在那个子树中，那么目标节点相对于传入的参考根节点的深度就是该子节点返回的深度值加1。
- 如果遍历完所有子节点仍未找到，返回-1。
JavaScript实现示例 (按节点实例查找)
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代码解释: getDepthWithRespectTo(rootNode) 方法定义在 Node 类上。它首先检查调用者 (this) 是否就是传入的 rootNode。如果是，深度为 0。否则，它会遍历 rootNode 的子节点。关键在于，它递归调用的是 this.getDepthWithRespectTo(child)，这意味着目标节点 (this) 正在询问它自己相对于 child 节点的深度。如果 child 节点的子树中包含 this 并且返回了非负深度，那么 this 相对于 rootNode 的深度就是那个返回值加 1。
通用注意事项与最佳实践
- 术语选择: “深度”（Depth）和“层级”（Level）在许多上下文中可以互换使用，但“深度”通常更侧重于节点到根的距离，而“层级”有时可能从1开始计数（根为1）。在本文中，我们统一采用根节点深度为0的约定。
- 错误处理: 当目标节点不存在于树中时，返回 -1 是一个常见的约定，它清晰地表示了“未找到”的状态。
-
性能考量: 这两种递归方法都需要在最坏情况下遍历树的大部分节点才能找到目标。对于非常大的树，如果频繁查询，可以考虑：
- 缓存深度: 在节点对象上存储其深度，但更新树结构时需要重新计算。
- 广度优先搜索 (BFS): BFS 也可以用于查找节点并计算深度，但递归的深度优先搜索 (DFS) 在实现上更简洁。
- 树结构的一致性: 确保所有节点都具有 name 和
