剑指Offer_#68-II_二叉树的最近公共祖先

剑指Offer_#68-II_二叉树的最近公共祖先

剑指offer

Contents

题目

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为：“对于有根树 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. p 和 q在 root的子树中，且分列 root 的 异侧（即分别在左、右子树中）；
  2. p = root，且 q 在 root的左或右子树中；
  3. q = root ，且 p在 root 的左或右子树中；

排除了上述情况之后，只剩下一种情况，即p 和 q在 root的子树中，且都在 root 的 同侧（即都在左子树种或都在右子树中),此时root必然不是最近的祖先，因为root下方肯定还有更近的祖先。

思路1：递归后序遍历

为什么是后续遍历？因为一个节点是否是p,q的公共祖先，必须先看其左右子树当中是否包含p,q。

终止条件

root == null || root == p || root == q,直接返回root。

  • root == p || root == q代表找到了p,q
  • root == null代表遍历到叶节点也没找到p,q，返回null

递推过程

  1. 开启左子树递归，也就是在左子树继续寻找p,q,并记录返回值left
  2. 开启右子树递归，也就是在右子树继续寻找p,q,并记录返回值right
  • 返回值不是null,代表的就是p,q的公共祖先
  • 返回值是null，表示这个子树里没有p,q的公共祖先

返回值

返回值表示的是最近公共祖先，没找到最近公共祖先时，返回值都是null；找到了最近公共祖先后，会将这个节点回溯到二叉树根节点，作为最后的返回值。

  1. left和right都为空，说明当前节点的左右子树里找不到p,q的公共祖先，那么返回null
  2. left和right都不为空，说明p,q就分别在当前节点的左右子树当中，当前节点就是公共祖先
  3. left和right有一个为空，另一个非空，说明p,q只可能在非空的那个子树当中，返回非空的子树根节点

思路2：到p,q的路径的最后共同节点

这是书上的解法，首先找到以根节点开始，以p,q结尾的两条路径。然后找到两条路径公共部分的最后一个节点，就是最近的公共祖先节点。如下图。

寻找路径采用前序遍历+回溯的方法。

解答

解答1:递归后序遍历

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root == null || root == p || root == q) return root;
        //找左子树当中的p或q，保存到left当中
        TreeNode left = lowestCommonAncestor(root.left, p, q);
        //找右子树当中的p或q，保存到right当中
        TreeNode right = lowestCommonAncestor(root.right, p, q);
        if(left == null && right == null) return null;
        //如果left和right之一为null,那么最近公共祖先只能是在非null那个子树当中
        if(left == null) return right;
        if(right == null) return left;
        //根据root左子树和右子树的搜索结果，判断root是否是p,q的公共祖先
        //如果left和right非空，说明root就是最近的公共祖先
        return root;     
    }
}

复杂度分析

时间复杂度O(n),最多需要遍历所有节点
空间复杂度O(n)，最差的时候，需要开启n层递归，占用的栈空间是O(n)

解答2：到p,q的路径的最后共同节点

class Solution {   
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        List<TreeNode> path1 = new ArrayList<>();
        List<TreeNode> path2 = new ArrayList<>();
        getPath(root,p,path1);
        getPath(root,q,path2);
        TreeNode res = null;
        //因为res在公共路径上，所以只需要取较小的路径长度即可
        int n = Math.min(path1.size(),path2.size());
        //公共路径最后一个节点就是最近的公共祖先
        for(int i = 0;i < n;i++){
            if(path1.get(i) == path2.get(i)) res = path1.get(i);
        }
        return res;
    }
    //前序遍历搜索p,q,保存路径
    void getPath(TreeNode root,TreeNode node,List<TreeNode> path){
        if(root == null) return;
        path.add(root);
        if(root == node) return;
        //为什么要重复写if语句？因为getPath()之后path就变化了，需要重新判断
        if(path.get(path.size()-1)!=node){
            getPath(root.left,node,path);
        }
        if(path.get(path.size()-1)!=node){
            getPath(root.right,node,path);
        }
        if(path.get(path.size()-1)!=node){
            path.remove(path.size()-1);
        }
    }
}

复杂度分析

时间复杂度：O(n),需要遍历两次树，得到到p和到q的节点，每一次是O(n),加起来也是O(n)
空间复杂度：使用path1,path2保存路径，最差情况是O(n),一般情况是O(logn)

posted @ 2020-07-26 18:15  Howfar's  阅读(190)  评论(0)  编辑  收藏  举报