LeetCode 练习——关于二叉树的最近公共祖先两道题

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

1.1 题目描述

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

百度百科中最近公共祖先的定义为：“对于有根树 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, 因为根据定义最近公共祖先节点可以为节点本身。

1.2 解题思路与代码

1.2.1 解题思路

这道题需要抓住重点：搜索二叉树，那么这道题就比较简单了，我们使用递归遍历二叉树。当我们遍历一个节点时对于给定的两个节点 p 和 q 只会出现三种情况：

p 和 q 的值都比当前节点小，即 p 和 q 都在当前节点的左子树上，此时我们就往 left 上继续遍历；
p 和 q 的值都比当前节点大，即 p 和 q 都在当前节点的右子树上，此时我们就往 right 上继续遍历；
p 比当前节点大 q 比当前节点小或者p 比当前节点小 q 比当前节点大，即此时 p 和 q 分别在当前节点的左右子树上，则当前节点便是 p 和 q 的公共祖先

1.2.2 代码

class Solution {
    TreeNode node = null;

    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        process(root,p,q);
        return node;
    }

    public void process(TreeNode root, TreeNode p, TreeNode q) {
        if (root == null) {
            return;
        }
        if (root.val < p.val && root.val < q.val) {
            process(root.right, p, q);
        } else if (root.val > p.val && root.val > q.val) {
            process(root.left, p, q);
        } else {
            node = root;
            return;
        }
    }
}

1.3 测试结果

通过测试

测试结果

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

2.1 题目描述

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.2 解题思路与代码

2.2.1 解题思路

遇上一道题不同的是，这道题就是一个普通的二叉树，节点上就不存在大小关系了，不能再用上面的思路。那么我们可以先递归遍历整个二叉树，并使用 map 存放当前节点和父节点的映射。二叉树遍历完成之后然后从 map 中获取 p 节点开始依次向上遍历，并使用集合存放遍历的路径。然后再从 map 中获取 q 节点并依次向上遍历，当在 p 的路径集合中到找到 q 向上遍历的节点时，便找到了公共祖先。即从 p 节点和 q 节点往上便利，当遇到第一个相同节点时，便是公共祖先。

2.2.2 代码


class Solution {
    Map<TreeNode, TreeNode> map = new HashMap<>();

    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        process(null, root);
        Set<TreeNode> set = new HashSet<>();
        while (p != null) {
            set.add(p);
            p = map.get(p);
        }
        while (!set.contains(q)){
            q = map.get(q);
        }
        return q;
    }

    public void process(TreeNode parent, TreeNode node) {
        if (node == null) {
            return;
        }
        if (parent != null) {
            map.put(node, parent);
        }
        process(node, node.left);
        process(node, node.right);
    }
}

2.3 测试结果