【Leetcode062】二叉搜索树的最近公共祖先

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。

示例 2:
输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
输出: 2
解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。

说明:
所有节点的值都是唯一的。
p、q 为不同节点且均存在于给定的二叉搜索树中。

方法一：二次遍历

1.1 思路分析

注意题目给出的是二叉搜索树，要把二叉搜索树的性质用出来：左子树的节点一定比根节点小，右子树的节点一定比根节点大。

定义两个路径列表，分别存储两个目标的查找路径。

然后遍历比较路径，如果出现不同值，就说明从该处分叉，进入不同的子树。

该分叉点便是祖先

1.2 代码实现

/**
 * 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) {
        List<TreeNode> p_path = getPath(root, p);   // 获取p的路径
        List<TreeNode> q_path = getPath(root, q);   // 获取q的路径
        TreeNode ancestor = null;       // 祖先
        for(int i=0; i<p_path.size() && i< q_path.size(); i++){
            if (q_path.get(i) == p_path.get(i)){    // 相等进入下一个
                ancestor = q_path.get(i);
            }else {     // 不相等说明分叉了，此处就是祖先节点
                break;
            }
        }
        return ancestor;
    }

    public List<TreeNode> getPath(TreeNode node, TreeNode target){
        List<TreeNode> path = new ArrayList<TreeNode>();
        while(node != target){
            path.add(node);
            if (node.val > target.val){
                node = node.left;
            }else {
                node = node.right;
            }
        }
        path.add(node);
        return path;
    }
}

1.3 测试结果

1.4 复杂度

• 时间复杂度：O(n)
• 空间复杂度：O(n)

方法二：一次遍历

2.1 思路分析

从根节点开始一起往下遍历，如果p, q都大于root，进入右子树，如果p, q都小于root，进入左子树；否则返回当前节点即可（分叉了）

2.2 代码实现

/**
 * 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) {
        while(root != null){
            if (root.val < p.val && root.val < q.val){		// 都大于根
                root = root.right;
            }else if (root.val > p.val && root.val > q.val){  // 都小于根
                root = root.left;
            }else{		// 出现祖先，分叉了
                break;
            }
        }
        return root;
    }
}

2.3 测试结果

2.4 复杂度

• 时间复杂度：O(n)
• 空间复杂度：O(n)

方法三：递归

3.1 思路分析

将方法二改写成递归形式

3.2 代码实现

/**
 * 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) {
        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;
    }
}

3.3 测试结果

3.4 复杂度

• 时间复杂度：O(n)
• 空间复杂度：O(n)