数据结构——二叉树的公共祖先问题

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

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

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

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

例如，给定如下二叉树: 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 为不同节点且均存在于给定的二叉树中。

思路

1、二叉树如果能自底向上查找，就可以找到公共祖先。自底向上查找需要利用回溯，后序遍历就是天然的回溯过程，最先处理的一定是叶子节点。

2、判断一个节点是节点q和节点p的公共公共祖先：如果找到一个节点，发现左子树出现结点p，右子树出现节点q，或者 左子树出现结点q，右子树出现节点p，那么该节点就是节点p和q的最近公共祖先。

• 递归函数返回值以及参数：要返回最近公共节点，返回值是TreeNode ，如果遇到p或者q，就把q或者p返回，返回值不为空，就说明找到了q或者p。
• 终止条件：如果找到了 节点p或者q，或者遇到空节点，就返回。
• 单层递归逻辑：
  本题函数有返回值，是因为回溯的过程需要递归函数的返回值做判断，但本题我们依然要遍历树的所有节点。
  要遍历整棵树是因为后序遍历中，如果想利用left和right做逻辑处理， 不能立刻返回，而是要等left与right逻辑处理完之后才能返回。所以即使在左子树中找到了p和q，仍要等right遍历完右子树。
  用left和right接住左子树和右子树的返回值，
  如果left 和 right都不为空，说明此时root就是最近公共节点。
  如果left为空，right不为空，就返回right，说明目标节点是通过right返回的，反之依然。
  
  图中节点10的左子树返回null，右子树返回目标值7，那么此时节点10的处理逻辑就是把右子树的返回值（最近公共祖先7）返回上去！左子树的返回值空被舍弃。最终结果被传至根节点。
  如果left和right都为空，则返回left或者right都是可以的，也就是返回空。

代码随想录完整流程图：

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

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if (root == null || root == p || root == q) return root;
        // 后序遍历
        TreeNode left = lowestCommonAncestor(root.left, p, q);
        TreeNode right = lowestCommonAncestor(root.right, p, q);

        if(left == null && right == null) { // 若未找到节点 p 或 q
            return null;
        }else if(left == null && right != null) { // 若找到一个节点
            return right;
        }else if(left != null && right == null) { // 若找到一个节点
            return left;
        }else { // 若找到两个节点
            return root;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

总结：

在递归函数有返回值的情况下：

• 如果要搜索一条边，递归函数返回值不为空的时候，立刻返回；
• 如果搜索整个树，直接用一个变量left、right接住返回值，这个left、right后序还有逻辑处理的需要，也就是后序遍历中处理中间节点的逻辑（也是回溯）。

搜索一条边的写法：

if (递归函数(root.left)) return ;

if (递归函数(root.right)) return ;
1
2
3

搜索整个树写法：

left = 递归函数(root.left);
right = 递归函数(root.right);
left与right的逻辑处理;
处理后再返回
1
2
3
4

235. 二叉搜索树的最近公共祖先

235. 二叉搜索树的最近公共祖先

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

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

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

示例 1:

• 输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
• 输出: 6
• 解释: 节点 2 和节点 8 的最近公共祖先是 6。

示例 2:

• 输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
• 输出: 2
• 解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。

说明:

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

思路

二叉搜索树是有序的，因此只要从上到下遍历的时候，cur节点是数值在[p, q]区间中则说明该节点cur就是最近公共祖先了。而且不需要遍历整棵树，找到结果直接返回即可。

1.递归

• 递归函数返回值以及参数：参数就是当前节点，以及两个结点 p、q。
  返回值是要返回最近公共祖先，所以是TreeNode 。
• 终止条件：遇到空返回就可以了。（其实都不需要这个终止条件，因为题目中说了p、q 为不同节点且均存在于给定的二叉搜索树中。也就是说一定会找到公共祖先的，所以并不存在遇到空的情况。）
• 单层递归的逻辑：在遍历二叉搜索树的时候就是寻找区间[p->val, q->val]（注意这里是左闭右闭）
  那么如果 root->val 大于 p->val，同时 root->val 大于q->val，那么就应该向左遍历（说明目标区间在左子树上）。此时不知道p和q谁大，所以两个都要判断
  如果 root->val 小于 p->val，同时 root->val 小于 q->val，那么就应该向右遍历（目标区间在右子树）。
  剩下的情况，就是cur节点在区间（p->val <= root->val && root->val <= q->val）或者 （q->val <= root->val && root->val <= p->val）中，root就是最近公共祖先了，直接返回root。

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

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if (root==null) return root; //可不加
        if (root.val>p.val && root.val>q.val)
            return lowestCommonAncestor(root.left,p,q);
        if (root.val<p.val && root.val<q.val)
            return lowestCommonAncestor(root.right,p,q);
        return root;
    }
}
1
2
3
4
5
6
7
8
9
10

2.迭代

利用二叉搜索树的有序性，写出简易迭代法

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

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        while (true) {
            if (root.val>p.val && root.val>q.val)
                root = root.left;
            else if (root.val<p.val && root.val<q.val)
                root = root.right;
            else 
                break;
        }
        return root;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13