剑指--二叉树的最近公共祖先

剑指–二叉树的最近公共祖先

都是寻找最近公共祖先，为什么这两道题是不一样的啊。这里附上另外一道题：剑指–二叉搜索树的最近公共祖先
因为这道题是：二叉搜索树的最近公共祖先（也就是这棵树的左节点的值<root的值<右节点的值，所以这棵树寻找最近公祖先是比较简单的）。但是现在这道题的这棵树的值是没有规律的，所以寻找最近祖先是稍微麻烦点。

1，题目：

2，思路：

方法一：递归写法

1.根据以上定义，若 root 是 p,q 的 最近公共祖先 ，则只可能为以下情况之一：

2.p 和 q 在 root 的子树中，且分列 root 的 异侧（即分别在左、右子树中）；
3.p=root ，且 q 在 root 的左或右子树中；
4.q=root ，且 p 在 root 的左或右子树中；

递归解析：

• 1.终止条件：

  • 当越过叶节点，则直接返回 null；
  • 当 root 等于 p,q ，则直接返回 root ；

• 2.递推工作：

  • 开启递归左子节点，返回值记为 left ；

  • 开启递归右子节点，返回值记为 right ；

• 3.返回值： 根据 left 和 right ，可展开为四种情况；

  • 当 left 和 right 同时为空 ：说明 root 的左 / 右子树中都不包含p,q ，返回 null；

  • 当 left 和 right 同时不为空 ：说明 p,q 分列在 root 的 异侧 （分别在 左 / 右子树），因此 root
    为最近公共祖先，返回 root ；

  • 当 left 为空 ，right 不为空 ：p,q 都不在 root 的左子树中，直接返回 righ 。具体可分为两种情况：

    • p,q 其中一个在 root 的 右子树 中，此时 right 指向 pp（假设为 p）；

    • p,q 两节点都在 root 的 右子树 中，此时的 right 指向 最近公共祖先节点 ；

• 4.当 left 不为空 ， right 为空 ：与情况 3. 同理；

下面是对应的图解：

方法二：非递归（队列）

要想找到两个节点的最近公共祖先节点，我们可以从两个节点往上找，每个节点都往上走，一直走到根节点，那么根节点到这两个节点的连线肯定有相交的地方，如果是从上往下走，那么最后一次相交的节点就是他们的最近公共祖先节点

3，代码：

方法一：递归写法

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        /*
        1.根据以上定义，若 root 是 p,q 的 最近公共祖先 ，则只可能为以下情况之一：

2.p 和 q 在 root 的子树中，且分列 root 的 异侧（即分别在左、右子树中）；
3.p=root ，且 q 在 root 的左或右子树中；
4.q=root ，且 p 在 root 的左或右子树中；



递归解析：
1.终止条件：
   当越过叶节点，则直接返回 null；
   当 root 等于 p,q ，则直接返回 root ；
2.递推工作：
   开启递归左子节点，返回值记为 left ；
   开启递归右子节点，返回值记为 right ；
3.返回值： 根据 left 和 right ，可展开为四种情况；
   当 left 和 right 同时为空 ：说明 root 的左 / 右子树中都不包含p,q ，返回 null；
   当 left 和 right 同时不为空 ：说明 p,q 分列在 root 的 异侧 （分别在 左 / 右子树），因此 root 为最近公共祖先，返回 root ；
   当 left 为空 ，right 不为空 ：p,q 都不在 root 的左子树中，直接返回 righ 。具体可分为两种情况：
   p,q 其中一个在 root 的 右子树 中，此时 right 指向 pp（假设为 p）；
   p,q 两节点都在 root 的 右子树 中，此时的 right 指向 最近公共祖先节点 ；
4.当 left 不为空 ， right 为空 ：与情况 3. 同理；


        */
        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) return right;
        if(right == null) return left;
        return root;
    }
}

方法二：非递归（队列）

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        /*
        要想找到两个节点的最近公共祖先节点，我们可以从两个节点往上找，每个节点都往上走，一直走到根节点，那么根节点到这两个节点的连线肯定有相交的地方，如果是从上往下走，那么最后一次相交的节点就是他们的最近公共祖先节点


        */
            //记录遍历到的每个节点的父节点。
            Map<TreeNode, TreeNode> parent = new HashMap<>();
            Queue<TreeNode> queue = new LinkedList<>();
            parent.put(root, null);//根节点没有父节点，所以为空
            queue.add(root);
            //直到两个节点都找到为止。
            while (!parent.containsKey(p) || !parent.containsKey(q)) {
                //队列是一边进一边出，这里poll方法是出队，
                TreeNode node = queue.poll();
                if (node.left != null) {
                    //左子节点不为空，记录下他的父节点
                    parent.put(node.left, node);
                    //左子节点不为空，把它加入到队列中
                    queue.add(node.left);
                }
                //右节点同上
                if (node.right != null) {
                    parent.put(node.right, node);
                    queue.add(node.right);
                }
            }
            Set<TreeNode> ancestors = new HashSet<>();
            //记录下p和他的祖先节点，从p节点开始一直到根节点。
            while (p != null) {
                ancestors.add(p);
                p = parent.get(p);
            }
            //查看p和他的祖先节点是否包含q节点，如果不包含再看是否包含q的父节点……
            while (!ancestors.contains(q))
                q = parent.get(q);
            return q;
        }

}