剑指 Offer 68 - II. 二叉树的最近公共祖先

Posted 2021-09-13 炫云云

剑指 Offer 68 - II. 二叉树的最近公共祖先

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4]

示例 1:

输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1

输出: 3

解释: 节点 5 和节点 1 的最近公共祖先是节点 3。

示例 2:

输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4

输出: 5

解释: 节点 5 和节点 4 的最近公共祖先是节点 5。因为根据定义最近公共祖先节点可以为节点本身。

说明:

• 所有节点的值都是唯一的。
• p、q 为不同节点且均存在于给定的二叉树中。

递归

思路和算法

我们递归遍历整棵二叉树，定义$f_x$表示 $x$ 节点的子树中是否包含 $p$ 节点或 $q$ 节点，如果包含为 true，否则为 false。那么符合条件的最近公共祖先 $x$ 一定满足如下条件：
$$(f_{\text{lson}}\&\&f_{\text{rson}})||((x=p||x=q)\&\&(f_{\text{lson}}||f_{\text{rson}}))$$
其中 $\text{lson}$ 和 $\text{rson}$ 分别代表 $x$ 节点的左孩子和右孩子。

$f_{\text{lson}}\&\&f_{\text{rson}}$ 说明左子树和右子树均包含 $p$ 节点或 $q$ 节点，如果左子树包含的是 $p$节点，那么右子树只能包含 $q$节点，反之亦然，因为 $p$ 节点和 $q$ 节点都是不同且唯一的节点，因此如果满足这个判断条件即可说明 $x$ 就是我们要找的最近公共祖先。

再来看第二条判断条件，这个判断条件即是考虑了 $x$ 恰好是 p 节点或 q 节点且它的左子树或右子树有一个包含了另一个节点的情况，因此如果满足这个判断条件亦可说明 x 就是我们要找的最近公共祖先。

你可能会疑惑这样找出来的公共祖先深度是否是最大的。其实是最大的，因为我们是自底向上从叶子节点开始更新的，所以在所有满足条件的公共祖先中一定是深度最大的祖先先被访问到，且由于 $f_x$ 本身的定义很巧妙，在找到最近公共祖先 $x$ 以后，$f_x$按定义被设置为 true ，即假定了这个子树中只有一个 $p$ 节点或 $q$ 节点，因此其他公共祖先不会再被判断为符合条件。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def lowestCommonAncestor(self, root, p, q):
        """递归是自底向上
        :type root: TreeNode
        :type p: TreeNode
        :type q: TreeNode
        :rtype: TreeNode
        """
        res = []
        def backtrack(node):
            if not node:
                return False
            lson = backtrack(node.left)
            rson = backtrack(node.right)
            if (lson and rson) or ((lson or rson) and (node.val ==p.val or ndoe.val == q.val) ):
                res.append(node)
                return True
            return lson or rson or (node.val == q.val or node.val ==p.val)
        backtrack(root)
        return res[0]

存储父节点

我们可以用哈希表存储所有节点的父节点，然后我们就可以利用节点的父节点信息从 p 结点开始不断往上跳，并记录已经访问过的节点，再从 q 节点开始不断往上跳，如果碰到已经访问过的节点，那么这个节点就是我们要找的最近公共祖先。

算法

• 从根节点开始遍历整棵二叉树，用哈希表记录每个节点的父节点指针。
• 从 p 节点开始不断往它的祖先移动，并用数据结构记录已经访问过的祖先节点。
• 同样，我们再从 q 节点开始不断往它的祖先移动，如果有祖先已经被访问过，即意味着这是 p 和 q 的深度最深的公共祖先，即 LCA 节点。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def lowestCommonAncestor(self, root, p, q):
        """递归是自底向上
        :type root: TreeNode
        :type p: TreeNode
        :type q: TreeNode
        :rtype: TreeNode
        """
        visited = set()
        parent ={}#哈希结构
        def backtrack(node):
            if not node:
                return
            if node.left:
                parent[node.left.val] = node #即左子节点的父节点为 node
                backtrack(node.left)
            if node.right:
                parent[node.right.val] = node
                backtrack(node.right)
        backtrack(root)

        while p:
            visited.add(p)
            p = parent.get(p.val) # 获取父节点,一直跳到根节点
        while q:
            if q in visited:
                return q
            q = parent.get(q.val)

参考

Krahets - 力扣（LeetCode） (leetcode-cn.com)