剑指 offer 68-01 二叉搜索树的最近公共祖先

剑指 offer 68-01 二叉搜索树的最近公共祖先

两次遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        // TreeNode pre=root;
        List<TreeNode> path_p = new LinkedList<>();
        List<TreeNode> path_q = new LinkedList<>();
        path_p = getPath(root,p);
        path_q = getPath(root,q);
        TreeNode ancestry = root;
        int len = Math.min(path_p.size(),path_q.size());
        for(int i=0;i<len;i++){
            if(path_p.get(i).equals(path_q.get(i))){
                ancestry = path_q.get(i);
            }else{
                break;
            }
        }
        return ancestry;
    }
    public List<TreeNode> getPath(TreeNode root,TreeNode p){
        List<TreeNode> path = new LinkedList<>();
        TreeNode node = root;
        while(true){
            path.add(node);
            if(node.val < p.val){
                node = node.right;
            }
            else if(node.val>p.val){
                node = node.left;
            }
            else{
                // path.add(node);
                break;
            }
        }
        return path;
    }
}

时间复杂度$O(n)$，$n$是给定的二叉搜索树中的节点个数。上述代码需要的时间与节点$p,q$在树中的深度线性相关，在最坏的情况下，树呈现链式结构，$p$和$q$一个是树的唯一叶子节点，一个是该叶子节点的父节点，此时的时间复杂度是$O(n)$。
空间复杂度$O(n)$，需要存储根节点到$p,q$的路径。在最坏的情况下，路径的长度是$O(n)$，因此需要$O(n)$的空间。

一次遍历 递归

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        // TreeNode pre=root;
        // TreeNode cur=root;
        if(root==null){
            return null;
        }
        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;
        
        
    }
}

时间复杂度$O(n)$。
空间复杂度$O(n)$，递归栈，最坏情况下，树呈现链式结构，$p$和$q$一个是树的唯一叶子节点，一个是该叶子节点的父节点，此时的空间复杂度是$O(n)$。

一次遍历 循环

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        // TreeNode pre=root;
        TreeNode cur=root;
        if(root==null){
            return null;
        }
        while(true){
            if(cur.val<p.val && cur.val<q.val){
                cur = cur.right;
            }
            else if(cur.val>p.val && cur.val>q.val){
                cur = cur.left;
            }else{
                break;
            }
        }
        return cur;
        
    }
}

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