【每日一题】力扣236 二叉树的最近公共祖先

---

题目

题目链接：力扣236：二叉树的最近公共祖先

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

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点x，满足x是p、q的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

示例 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 。因为根据定义最近公共祖先节点可以为节点本身。

示例 3：

输入：root = [1,2], p = 1, q = 2
输出：1

提示：

• 树中节点数目在范围 [2, 10⁵] 内。
• -10⁹ <= Node.val <= 10⁹
• 所有 Node.val 互不相同 。
• p != q
• p 和 q 均存在于给定的二叉树中。

解题思路

👉法一

递归遍历二叉树，用回溯从底向上查找p和q的节点（后序遍历），查找到节点所在位置并且回溯时，返回节点的位置。这里可以只返回节点是左孩子还是右孩子。如果是左孩子，那么其父节点的左孩子调用的那个函数可以接收到信号。

当找到第二个节点后，同样返回其位置，只有当一个节点的左孩子和右孩子同时有返回的信号时，那个节点就是最近公共祖先。

下面给出伪代码：

bool l = dfs(左孩子);
bool r = dfs(右孩子);
if (l && r) {
	找到公共祖先
}
return l || r || 是否找到节点

👉法二

第二种方法是用哈希表存储父节点，然后再遍历节点，找公共祖先。这种方法空间复杂度较大，时间复杂度也没有优化。

先遍历二叉树，把二叉树的节点的父节点存储起来。然后遍历标记节点p及其父节点，遍历q时，只要找到已被标记的节点，即是要找的公共祖先。

代码（C++）

法一

class Solution {
public:
    TreeNode *t;
    bool dfs(TreeNode *root, TreeNode *p, TreeNode *q) {
        if (!root)
            return false;
        bool l = dfs(root->left, p, q);
        bool r = dfs(root->right, p, q);
        if ((l && r) || p->val == root->val || q->val == root->val ) {
            t = root;
        }
        return l || r || p->val == root->val || q->val == root->val;
    }

    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        dfs(root, p, q);
        return t;
    }
};

法二

class Solution {
public:
    unordered_map<int, TreeNode *> fa;
    unordered_map<int, bool> vis;
    void dfs(TreeNode *root) {
        if (root->left) {
            fa[root->left->val] = root;
            dfs(root->left);
        }
        if (root->right) {
            fa[root->right->val] = root;
            dfs(root->right);
        }
    }

    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        dfs(root);
        while (p) {
            vis[p->val] = true;
            p = fa[p->val];
        }
        while (q) {
            if (vis[q->val])
                return q;
            q = fa[q->val];
        }
        return NULL;
    }
};

总结

这题想到了不难，没想到是真没思路，我开始想的是用层次遍历，但发现太麻烦就没写了。这两种方法其实是相似的，或者说原理是相同的。都是先查找一个节点，并标记其祖先节点，再查找另一个节点，发现其祖先节点已被标记了，就找到了答案。