二叉树最近公共祖先相关题目（Leetcode题解-Python语言）

236. 二叉树的最近公共祖先

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':

        def dfs(root: 'TreeNode', p: 'TreeNode', q: 'TreeNode'):
            # 如果当前节点为空，则说明 p、q 不在 node 的子树中，不可能为公共祖先，直接返回 None
            if not root:
                return None
            
            # 如果当前节点 root 等于 p 或者 q，那么 root 就是 p、q 的最近公共祖先，直接返回 root，不需要遍历子树了
            if root == p or root == q:
                return root
            
            # 递归遍历左子树、右子树，并判断左右子树结果
            node_left = dfs(root.left, p, q)
            node_right = dfs(root.right, p, q)
            # 如果左右子树都不为空，则说明 p、q 在当前根节点的两侧，当前根节点就是他们的最近公共祖先
            if node_left and node_right:
                return root

            return node_left if node_left else node_right
        
        ans = dfs(root, p, q)
        return ans

在递归函数 dfs 中，我们是先判断 root 是否等于 p 或者 q，再遍历其左右子树，这样可以应对两种情况：1、p 或者 q 在最近公共祖先的两侧，此时由于祖先作为 root 不等于p、q，所以左右子树都会被遍历，从而逐级向上返回，得到祖先的左右子树都不为空，返回 root；2、
p 或者 q 自身就是最近公共祖先，此时满足 root 等于 p 或 q，直接返回 root 即可。

1676. 二叉树的最近公共祖先 IV

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', nodes: 'List[TreeNode]') -> 'TreeNode':

        def dfs(root: 'TreeNode', nodes: 'List[TreeNode]'):
            # 如果当前节点为空，则说明 p、q 不在 node 的子树中，不可能为公共祖先，直接返回 None，不需要遍历子树了
            if not root:
                return None
            
            # 如果当前节点 root 等于 p 或者 q，那么 root 就是 p、q 的最近公共祖先，直接返回 root
            for node in nodes:
                if root == node:
                    return root
            
            # 递归遍历左子树、右子树，并判断左右子树结果
            node_left = self.dfs(root.left, nodes)
            node_right = self.dfs(root.right, nodes)
            # 如果左右子树都不为空，则说明 p、q 在当前根节点的两侧，当前根节点就是他们的最近公共祖先
            if node_left and node_right:
                return root
            return node_left if node_left else node_right
        ans = dfs(root, nodes)
        return ans

与上一题同理，此题 p、q 换成了更多的节点，用列表 nodes 表示。

1644. 二叉树的最近公共祖先 II

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':

        def dfs(root: 'TreeNode', p: 'TreeNode', q: 'TreeNode'):
            nonlocal pFlag
            nonlocal qFlag
            # 如果当前节点为空，则说明 p、q 不在 node 的子树中，不可能为公共祖先，直接返回 None
            if not root:
                return None
            
            # 递归遍历左子树、右子树，并判断左右子树结果
            node_left = dfs(root.left, p, q)
            node_right = dfs(root.right, p, q)

            # 如果左右子树都不为空，则说明 p、q 在当前根节点的两侧，当前根节点就是他们的最近公共祖先
            if node_left and node_right:
                return root

            # 如果当前节点 root 等于 p 或者 q，那么 root 就是 p、q 的最近公共祖先，返回 root，子树也已经被遍历过了
            if root == p or root == q:
                if root == p:
                    pFlag = True
                if root == q:
                    qFlag = True
                return root

            return node_left if node_left else node_right

        pFlag = False
        qFlag = False
        ans = dfs(root, p, q)
        if not pFlag or not qFlag:
            return None
        return ans

这题需要用两个标志位记录 p 和 q 有没有出现过，如果其中之一没出现过就返回 None。这题的判断 root 是否等于 p 或 q 要放在遍历左右子树的后面，这是因为如果 root 等于 p 或 q 了然后返回，此时只有一个标志位是变成 True 的，但我们要两个标志位都为 True 时才返回 ans。所以我们要先遍历左右子树，再判断 root 的值，这样就会遍历到所有的节点，这种写法在前面两题也可以使用，但是在前面两题的情况下是属于效率低的。