# 剑指 Offer 68 - I. 二叉搜索树的最近公共祖先

1.题目

剑指 Offer 68 - I. 二叉搜索树的最近公共祖先
给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 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 为不同节点且均存在于给定的二叉搜索树中。

2.自我思路与实现

1.双指针
二叉搜索树的左子节点值<父节点<右子节点
使用两个指针p1和q1分别对应每次寻找p和q时经过的节点
若指针相等，说明此处是p和q的一个公共祖先，根据pq的值继续向下寻找
若指针不等，说明上一次两个指针指向的节点是最近的公共祖先
使用一个节点res来存储上一个两个指针指向的节点
代码详解：

1. 初始时res, p1, q1均指向根节点
2. 进入循环
   循环运行条件：两个指针相等
   res存储此时两个指针指向的节点
   根据比较p1和p的值的大小来确定p1移动的方向，相等则不移动
   q1同理
3. 返回res

/**
 * 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 p1 = root;
        TreeNode q1 = root;
        TreeNode res = root;
        while(p1 == q1)
        {
            res = p1;
            if(p1.val > p.val)
                p1 = p1.left;
            else if(p1.val < p.val)
                p1 = p1.right;
            if(q1.val > q.val)
                q1 = q1.left;
            else if(q1.val < q.val)
                q1 = q1.right;   
        }
        return res;
    }
}

时间N：最差情况下要遍历每个节点
空间1：额外定义三个节点

3.总结思路与实现

上述思路是一种迭代，其优化方案如下

• 直接判断pq是否在同一个子树上
  若是，则进入子树
  否则，直接返回当前树的根节点
  这样省去了定义三个额外节点
• 保证p.val<q.val的情况下，判断是否在同一个子树上只需比较一个值即可
  左子树，较大的值与根比较
  右子树，较小的值与根比较

/**
 * 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(p.val > q.val)
        {
            TreeNode temp = p;
            p = q;
            q = temp;
        }
        while(root != null)
        {
            if(q.val < root.val)
                root = root.left;
            else if(p.val > root.val)
                root = root.right;
            else
                break;

        }
        return root;
    }

}

• 比较过程可以改为与根的差，但代码没有比较来的易懂

2.递归
原理与上类似，
两节点都在左子树时，转入左子树
两节点都在右子树时，转入右子树
否则返回根节点
时间N
空间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) {
        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;
    }
}

3.迭代+动态数组
先找到从根到pq的路径节点并存储到动态数组里，再从前向后遍历两个动态数组，返回最后一个角标相同且节点相同的元素

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        List<TreeNode> path_p = getPath(root, p);
        List<TreeNode> path_q = getPath(root, q);
        TreeNode ancestor = null;
        for (int i = 0; i < path_p.size() && i < path_q.size(); ++i) {
            if (path_p.get(i) == path_q.get(i)) {
                ancestor = path_p.get(i);
            } else {
                break;
            }
        }
        return ancestor;
    }

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

4.相关知识