二叉树节点距离计算：LCA与深度优先搜索实战-代码聚汇网

二叉树节点距离计算：LCA与深度优先搜索实战

深度学习于NLP·2026-08-14·阅读 23 GEO检测（免费）

二叉树节点距离LCA算法

|难度：普通|阅读约 16 分钟

1. 项目概述：二叉树节点距离计算实战

在算法面试和编程竞赛中，"计算二叉树中两个节点之间的距离"是一个经典的高频考题。这道题看似简单，却融合了二叉树遍历、最近公共祖先（LCA）查找、深度计算等多个核心知识点。作为曾在多家头部互联网公司担任技术面试官的过来人，我发现这道题的解题思路能直观反映候选人对树结构的理解深度。

实际场景中，这种计算可以应用于社交网络中的关系亲密度测量、组织架构中的汇报层级分析，或是文件系统中目录间的跳转成本估算。比如在Git版本控制系统中，计算两个commit节点之间的距离可以帮助评估代码变更的跨度；在DOM树操作时，了解元素节点的距离关系有助于优化选择器性能。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 核心概念解析

2.1 问题精确定义

给定一棵二叉树和该树中的两个节点p、q，要求返回这两个节点之间的最短距离。距离定义为连接两个节点的路径上的边数。例如在下图中：

code复制       1
      / \
     2   3
    / \   \
   4   5   6

节点4和5的距离是2（路径4-2-5），节点4和6的距离是4（路径4-2-1-3-6）。

2.2 关键算法组件

解决这个问题需要三个核心计算模块：

LCA查找：找到两个节点的最近公共祖先
深度计算：计算任意节点到根节点的距离
距离公式：dist(p,q) = depth(p) + depth(q) - 2*depth(lca)

2.3 时间复杂度分析

最优解法应该达到O(n)时间复杂度和O(h)空间复杂度（h为树高），这要求我们：

只遍历必要的节点路径
避免重复计算深度
合理利用递归或迭代的遍历方式

3. 深度优先搜索实现方案

3.1 递归查找LCA

python复制def lowestCommonAncestor(root, p, q):
    if not root or root == p or root == q:
        return root
    left = lowestCommonAncestor(root.left, p, q)
    right = lowestCommonAncestor(root.right, p, q)
    if left and right:
        return root
    return left if left else right

这个经典实现利用了后序遍历的特性，当左右子树分别包含p和q时，当前节点就是LCA。

3.2 节点深度计算优化

传统深度计算需要单独遍历：

python复制def getDepth(node, target):
    if not node:
        return float('inf')
    if node == target:
        return 0
    return 1 + min(getDepth(node.left, target), 
                  getDepth(node.right, target))

但更高效的做法是在LCA查找过程中记录深度，避免重复遍历。

3.3 完整解决方案代码

python复制class Solution:
    def distance(self, root, p, q):
        def dfs(node):
            if not node or node == p or node == q:
                return node
            left = dfs(node.left)
            right = dfs(node.right)
            if left and right:
                return node
            return left or right
        
        def getDepth(node, target):
            if not node:
                return float('inf')
            if node == target:
                return 0
            left = getDepth(node.left, target)
            right = getDepth(node.right, target)
            return 1 + min(left, right)
        
        lca = dfs(root)
        return getDepth(lca, p) + getDepth(lca, q)

4. 迭代优化与性能提升

4.1 父指针记录法

通过哈希表存储每个节点的父指针，可以避免递归栈的开销：

python复制def recordParents(root):
    parent = {root: None}
    stack = [root]
    while stack:
        node = stack.pop()
        if node.left:
            parent[node.left] = node
            stack.append(node.left)
        if node.right:
            parent[node.right] = node
            stack.append(node.right)
    return parent

4.2 路径回溯法

找到两个节点到根节点的路径，然后比较路径差异：

python复制def getPath(parent, node):
    path = []
    while node:
        path.append(node)
        node = parent[node]
    return path

def findDistance(parent, p, q):
    path_p = getPath(parent, p)
    path_q = getPath(parent, q)
    i = len(path_p) - 1
    j = len(path_q) - 1
    while i >= 0 and j >= 0 and path_p[i] == path_q[j]:
        i -= 1
        j -= 1
    return (i + 1) + (j + 1)

4.3 时间复杂度对比

方法	时间复杂度	空间复杂度	适用场景
递归LCA	O(n)	O(h)	平衡树
父指针+路径回溯	O(n)	O(n)	频繁查询
深度记录	O(n)	O(n)	需要多次计算不同节点

5. 边界条件与异常处理

5.1 特殊输入处理

空树情况：直接返回-1或抛出异常
节点不存在：需要先验证节点是否在树中
节点相同：距离为0的特殊情况

5.2 验证节点存在性

python复制def validateNodes(root, p, q):
    nodes = set()
    stack = [root]
    while stack:
        node = stack.pop()
        if node:
            nodes.add(node)
            stack.append(node.left)
            stack.append(node.right)
    return p in nodes and q in nodes

5.3 鲁棒性增强方案

添加输入参数类型检查
处理节点值为None的情况
增加树结构合法性验证（防止循环引用）

6. 实际应用场景扩展

6.1 社交网络关系度计算

在社交网络的图谱分析中，可以用类似方法计算两个用户之间的关联强度。例如微信好友关系可以建模为二叉树（虽然实际是图结构），计算两个人之间的最短认识路径。

6.2 文件系统目录跳转

Linux系统中的cd命令跳转成本可以表示为目录节点距离。优化算法可以帮助预测最快捷的路径切换方式。

6.3 组织架构分析

计算公司汇报层级中两个员工的管理距离，可以用于评估信息传递效率或审批流程复杂度。

7. 常见面试问题与解答

7.1 如何优化多次查询？

使用离线Tarjan算法或在线倍增法预处理树结构，将每次查询时间复杂度降到O(1)。

7.2 如果树节点带权重怎么办？

将边数距离改为权重和，需要修改深度计算方式：

python复制def getWeightedDepth(node, target):
    if not node:
        return float('inf')
    if node == target:
        return 0
    left = node.left_weight + getWeightedDepth(node.left, target)
    right = node.right_weight + getWeightedDepth(node.right, target)
    return min(left, right)

7.3 非二叉树情况如何处理？

对于n叉树，算法逻辑不变，只需调整子节点遍历方式：

python复制for child in node.children:
    result = dfs(child)
    ...

8. 算法可视化与调试技巧

8.1 树结构打印工具

python复制def printTree(root, level=0):
    if root:
        printTree(root.right, level+1)
        print(' ' * 4 * level + '->', root.val)
        printTree(root.left, level+1)

8.2 调试断点设置

LCA查找时打印当前节点
深度计算时记录调用栈
最终距离计算前验证中间结果

8.3 测试用例设计

应包含以下场景：

两个节点在左右子树
一个节点是另一个的祖先
节点在树的同一侧
树退化为链表的情况
空树或节点不存在的情况

9. 性能优化进阶技巧

9.1 记忆化搜索

缓存已计算的节点深度：

python复制from functools import lru_cache

@lru_cache(maxsize=None)
def getDepth(node, target):
    ...

9.2 欧拉序+RMQ

将LCA问题转化为区间最小值问题，使用稀疏表实现O(1)查询：

通过欧拉遍历记录访问顺序
记录每个节点的首次出现位置
使用RMQ查询区间深度最小的节点

9.3 并行计算优化

对于特别大的树结构：

使用多线程分别计算两个节点的路径
采用MapReduce框架分布式处理

10. 代码风格与工程实践

10.1 面向对象封装

python复制class BinaryTreeDistance:
    def __init__(self, root):
        self.parent_map = self._record_parents(root)
    
    def get_distance(self, p, q):
        ...

10.2 单元测试编写

python复制import unittest

class TestTreeDistance(unittest.TestCase):
    def setUp(self):
        # 构建测试树
        ...
    
    def test_same_node(self):
        self.assertEqual(0, distance(root, n4, n4))
    
    def test_cousins(self):
        self.assertEqual(4, distance(root, n4, n6))

10.3 文档字符串规范

python复制def distance(root, p, q):
    """
    计算二叉树中两个节点之间的最短距离
    
    Args:
        root: 二叉树根节点
        p: 第一个目标节点
        q: 第二个目标节点
    
    Returns:
        int: 两个节点之间的边数距离
    
    Raises:
        ValueError: 如果节点不在树中
    """
    ...

在实际工程实现中，我建议将算法封装为独立的类或模块，并提供良好的接口文档。对于需要高频调用的场景，可以采用预处理+缓存策略提升性能。当处理超大树结构时，可以考虑使用数据库存储节点关系，或者采用更高级的图算法框架。