[M二叉树] lc236. 二叉树的最近公共祖先(dfs+二叉搜索树)

1. 题目来源

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

相似题：

• [M二叉树] lc235. 二叉搜索树的最近公共祖先(dfs+二叉搜索树)

题单：

• 【题单】链表、二叉树与一般树（前后指针/快慢指针/DFS/BFS/直径/LCA）
  • 二、二叉树
    • §2.8 最近公共祖先

2. 题目解析

很经典的题目哈，二刷的时候，再注意下非递归写法吧。

思路：

• 本题没有 BST 树这样好的性质，没有办法去确定到底去左边搜、还是右边搜。
• 故，那就两边都来搜一下就行了。看看 最近公共祖先 的本质是什么？
  • 本质：以当前节点为根节点所处的子树中，p，q 同时出现。那么当前节点即为 p，q 的最近公共祖先。
• 所以，我们需要一个 dfs 函数，它能获取到以当前 root 为节点的子树中，p、q 的出现情况。
• 这里也是借用了 先递归、再回溯，当遇见的第一个满足的节点，就一定是 最近的 公共祖先。

---

灵神的题解这个写的非常好，代码实现很简洁，dfs 返回值再考虑了多种情况下，合并了多种情况。值得思考下。

同时思考一个问题：

• 本题是最近公用祖先，但同时也有其他的公共祖先存在。
• 在 y总 的写法中是用了全局变量，配合递归回溯的时候，进行了首次的判断，后续的其他公共祖先就不会记录答案。
• 灵神这里直接这样写，不会受到其他公共祖先的影响吗？
  • 其实不会。
  • 以 left && right 成立时，root 为最近公共祖先为例。
  • 此时回溯上去，它是从 r1->left 或者 r1->right 来的。此时，其中一个分支肯定是不会包含 p、q 的，所以这个分支的回溯结果是 null。
  • 故，假设 r1->left 这个分支返回的结果就是 root。则 r1->right 这个分支返回的结果就是 null。
  • 所以进不去 left&&right，说明 root 并非 p、q 的最近公共祖先。所以上层的这个公共祖先，实际上不会被返回。
  • 然后判断 left 非空，说明在 left 已经找到了最近公共祖先，且公共祖先的位置是 left。继续向上返回即可。
  • 综上，其他的最近公共祖先，都不会被返回。能返回的只有最近的公共祖先。故此，将被层层返回到顶层，作为答案。

---

• 时间复杂度：$O(n)$
• 空间复杂度：$O(1)$

---

递归写法：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* res = NULL;
    int dfs(TreeNode* root, TreeNode* p, TreeNode* q) {
        if (!root) return 0;
        int st = 0;
        if (root == p) st |= 1;  // 看看根节点是不是 p
        else if (root == q) st |= 2; // 看看根节点是不是 q
        st |= dfs(root->left, p, q); // 看看左子树中包含 p、q 的情况
        st |= dfs(root->right, p, q); // 看看右子树中包含 p、q 的情况
        if (st == 3 && !res) res = root; // 回溯到根节点时，如果根节点子树中包含了 p, q 且 res 未被赋值，那就是最近公共祖先

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

包括这样写也是可以的：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* res = NULL;
    int dfs(TreeNode* root, TreeNode* p, TreeNode* q) {
        if (!root) return 0;
        int st = dfs(root->left, p, q);
        if (root == p) st |= 1;     // 这个状态转移，放这里，放下面都是可以的
        else if (root == q) st |= 2;
        st |= dfs(root->right, p, q);
        // if (root == p) st |= 1;     // 放这里也是可以的，只要遍历到了每个节点都行
        // else if (root == q) st |= 2;
        if (st == 3 && !res) res = root;
        return st;
    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        dfs(root, p, q);
        return res;
    }
};

---

灵神的简洁写法：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if (!root || root->val == p->val || root->val == q->val) return root; // 最近公共祖先位置、p、q 位置、null 位置
        auto left = lowestCommonAncestor(root->left, p, q);
        auto right = lowestCommonAncestor(root->right, p, q);
        if (left && right) return root;     // 最近公共祖先位置
        // 这里就保证了，如果在下层的 root 节点找到其为最近公共祖先的话
        // 就会层层返回上去，而非用上面的 root 值进行覆盖。
        // 所以，在这里不需要开辟外部的全局变量进行「首次遇见最近公共祖先」的这个记录
        return left ? left : right;
    }
};