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

文章目录

- [1. 题目来源](#1. 题目来源)
- [2. 题目解析](#2. 题目解析)

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(n) O(n)
空间复杂度 ： O ( 1 ) O(1) O(1)

递归写法：

cpp 复制代码

/**
 * 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;
    }
};

包括这样写也是可以的：

cpp 复制代码

/**
 * 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;
    }
};

灵神的简洁写法：

cpp 复制代码

/**
 * 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;
    }
};