LeetCode 235 二叉搜索树的最近公共祖先 题解

LeetCode 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。

方法：

1.两次遍历， 分别得出从根节点到两个节点的路径，找这两条路径的最后一个公共结点
时间复杂度：O(n)，其中 n 是给定的二叉搜索树中的节点个数。上述代码需要的时间与节点 p 和 q 在树中的深度线性相关，而在最坏的情况下，树呈现链式结构，p 和 q 一个是树的唯一叶子结点，一个是该叶子结点的父节点，此时时间复杂度为 O(n)。
空间复杂度：O(n)，我们需要存储根节点到 p 和 q 的路径。和上面的分析方法相同，在最坏的情况下，路径的长度为O(n)，因此需要O(n) 的空间。
2.一次遍历： 一个节点的左子树里有p，右子树里有q，那么当前节点就是最近公共祖先
这道题的二叉树是二叉搜索树，正好可以根据p、q和root的值的大小关系判断这两个点是同在左子树还是同在右子树还是一个左子树，一个右子树，如果是一左一右，就直接返回根节点，否则就转向左子树或者右子树
时间复杂度：O(n)，其中 n 是给定的二叉搜索树中的节点个数。
空间复杂度：O(1)。

class Solution {
    public TreeNode lowestCommonAncestor1(TreeNode root, TreeNode p, TreeNode q) {
        if(root == null){
            return root;
        }
        List<TreeNode> pPath = getPath(root,p);
        List<TreeNode> qPath = getPath(root,q);
        int length = Math.min(pPath.size(), qPath.size());
        TreeNode ancestor = null;
        //这样写的话，两个结点的路径不一样长时，就进入不到更新ancestor的语句里去了
        // for(int i = 0; i < length; ++i){
        //     if(pPath.get(i) != qPath.get(i)){
        //         ancestor = pPath.get(i - 1);
        //         break;
        //     }
        // }        
        for(int i = 0; i < length; ++i){
            if(pPath.get(i) == qPath.get(i)){
                ancestor = pPath.get(i);
            }
            else{
                break;
            }
        }
        return ancestor;

    }
    public List<TreeNode> getPath(TreeNode root,TreeNode target){
        List<TreeNode> list = new ArrayList<>();
        while(root != null){
            list.add(root);
            if(root == target){
                break;
            }
            //target值偏小，向左走
            if(root.val > target.val){
                root = root.left;
            }
            //target值偏大，向右走
            else {
                root = root.right;
            }
        }
        return list;
    }
}
public TreeNode lowestCommonAncestor2(TreeNode root, TreeNode p, TreeNode q) {
        if(root == null){
            return root;
        }
        TreeNode ancestor = root;
        while(true){
            //都在左子树里
            if(p.val < ancestor.val && q.val < ancestor.val){
                ancestor = ancestor.left;
            }
            //都在右子树里
            else if(p.val > ancestor.val && q.val > ancestor.val){
                ancestor = ancestor.right;
            }
            else {
                return ancestor;
            }
        }
    }
    //递归写法：
     public TreeNode lowestCommonAncestor2_1(TreeNode root, TreeNode p, TreeNode q) {
        if(root == null){
            return root;
        }
        if(p.val < root.val && q.val < root.val){
            return lowestCommonAncestor(root.left,p,q);
        }
        if(p.val > root.val && q.val > root.val){
            return lowestCommonAncestor(root.right,p,q);
        }
        return root;
    }
    //一行递归！！
     public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        return (root.val - p.val)*(root.val - q.val) <=0 ? root : lowestCommonAncestor((p.val < root.val) ? root.left : root.right, p, q);
    }