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

题目描述：

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

1.对于该题的最近的公共祖先定义:对于有根树T的两个节点p、q，最近公共祖先LCA(T,p,q)表示一个节点x，满足x是p和q的祖先且x的深度尽可能大。在这里，一个节点也可以是它自己的祖先.

2.二叉搜索树是若它的左子树不空，则左子树上所有节点的值均小于它的根节点的值； 若它的右子树不空，则右子树上所有节点的值均大于它的根节点的值

3.所有节点的值都是唯一的。

4.p、q 为不同节点且均存在于给定的二叉搜索树中。

数据范围:

3<=节点总数<=10000

0<=节点值<=10000

如果给定以下搜索二叉树: {7,1,12,0,4,11,14,#,#,3,5}，如下图:

示例1

输入：{7,1,12,0,4,11,14,#,#,3,5},1,12

返回值：7

说明：节点1 和 节点12的最近公共祖先是7

示例2

输入：{7,1,12,0,4,11,14,#,#,3,5},12,11

返回值：12

说明：因为一个节点也可以是它自己的祖先.所以输出12

解法一：搜索路径

思路：

        先来看看二叉搜索树的特性：它的每个节点值大于它的左子节点，且大于全部左子树的节点值，小于它右子节点，且小于全部右子树的节点值。因此二叉搜索树一定程度上算是一种排序结构。

        二叉搜索树没有相同值的节点，因此分别从根节点往下利用二叉搜索树较大的数在右子树，较小的数在左子树，可以轻松找到p、q。这样就可以直接得到从根节点到两个目标节点的路径，这样我们利用路径比较就可以找到最近公共祖先。

        步骤如下：

• step 1：根据二叉搜索树的性质，从根节点开始查找目标节点，当前节点比目标小则进入右子树，当前节点比目标大则进入左子树，直到找到目标节点。这个过程成用数组记录遇到的元素。
• step 2：分别在搜索二叉树中找到p和q两个点，并记录各自的路径为数组。
• step 3：同时遍历两个数组，比较元素值，最后一个相等的元素就是最近的公共祖先。

代码：

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 *   public TreeNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @param p int整型 
     * @param q int整型 
     * @return int整型
     */
    public int lowestCommonAncestor (TreeNode root, int p, int q) {
        //找到p和q在二叉搜索树中的路径
        List<Integer> pList = getPath(root, p);
        List<Integer> qList = getPath(root, q);
        int ret = 0;
        //找到两条路径中最后一个相同值得位置，即为最近公共祖先
        for(int i=0; i< pList.size() && i < qList.size(); i++){
            int m = pList.get(i), n = qList.get(i);
            if(m == n){
                ret = pList.get(i);
            }else{
                break;
            }
        }
        return ret;
    }
    //查找目标值在二叉搜索树中的路径
    public List<Integer> getPath(TreeNode root, int target){
        //存储结果集
        List<Integer> list = new ArrayList<>();
        TreeNode node = root;
        //从根节点开始搜索
        while(node.val != target){
            list.add(node.val);
            //大于目标值就走左子树，否则就走右子树
            if(node.val > target){
                node = node.left;
            }else{
                node =  node.right;
            }
        }
        //找到结果
        list.add(node.val);
        return list;
    }
}

解法二：递归

思路：

        对于某一个节点，若是p与q都小于等于这个这个节点值，说明p、q都在这个节点的左子树，而最近的公共祖先也一定在这个节点的左子树；若是p与q都大于等于这个节点，说明p、q都在这个节点的右子树，而最近的公共祖先也一定在这个节点的右子树。而若是对于某个节点，p与q的值一个大于等于节点值，一个小于等于节点值，说明它们分布在该节点的两边，而这个节点就是最近的公共祖先，因此从上到下的其他祖先都将这个两个节点放到同一子树，只有最近公共祖先会将它们放入不同的子树，每次进入一个子树又回到刚刚的问题，因此可以使用递归。

        步骤如下：

• step 1：首先检查空节点，空树没有公共祖先。
• step 2：对于某个节点，比较与p、q的大小，若p、q在该节点两边说明这就是最近公共祖先。
• step 3：如果p、q都在该节点的左边，则递归进入左子树。
• step 4：如果p、q都在该节点的右边，则递归进入右子树。

代码：

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 *   public TreeNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @param p int整型 
     * @param q int整型 
     * @return int整型
     */
    public int lowestCommonAncestor (TreeNode root, int p, int q) {
        //空树找不到公共祖先
        if(root == null)
            return -1;
        //pq在该节点两边说明这就是最近公共祖先
        if((p >= root.val && q <= root.val) || (p <= root.val && q >= root.val))
            return root.val;
        //pq都在该节点的左边
        else if(p <= root.val && q <= root.val)
            //进入左子树
            return lowestCommonAncestor(root.left, p, q);
        //pq都在该节点的右边
        else
            //进入右子树
            return lowestCommonAncestor(root.right, p, q);
    }
}

来看另一道题：在二叉树中找到两个节点的最近公共祖先。

这道题区别与上一道题的点在于：前面可以利用二叉搜索树的特性，而二叉树并没有那个特性。但是我们可以借鉴上面那道题的实现思路。

题目描述：

给定一棵二叉树(保证非空)以及这棵树上的两个节点对应的val值 o1 和 o2，请找到 o1 和 o2 的最近公共祖先节点。

数据范围：树上节点数满足 1≤n≤105  , 节点值val满足区间 [0,n)

要求：时间复杂度O(n)

注：本题保证二叉树中每个节点的val值均不相同。

如当输入{3,5,1,6,2,0,8,#,#,7,4},5,1时，二叉树{3,5,1,6,2,0,8,#,#,7,4}如下图所示：

 

所以节点值为5和节点值为1的节点的最近公共祖先节点的节点值为3，所以对应的输出为3。

节点本身可以视为自己的祖先。

示例1

输入：{3,5,1,6,2,0,8,#,#,7,4},5,1

返回值：3

示例2

输入：{3,5,1,6,2,0,8,#,#,7,4},2,7

返回值：2

解法一：深度优先遍历

思路：

        深度优先搜索一般用于树或者图的遍历，其他有分支的（如二维矩阵）也适用。它的原理是从初始点开始，一直沿着同一个分支遍历，直到该分支结束，然后回溯到上一级继续沿着一个分支走到底，如此往复，直到所有的节点都有被访问到。

        既然要找到二叉树中两个节点的最近公共祖先，可以考虑先找到两个节点全部祖先，可以得到从根节点到目标节点的路径，然后依次比较路径得出谁是最近的祖先。

        步骤如下：

• step 1：利用dfs求得根节点到两个目标节点的路径：每次选择二叉树的一棵子树往下找，同时路径数组增加这个遍历的节点值。
• step 2：一旦遍历到了叶子节点也没有，则回溯到父节点，寻找其他路径，回溯时要去掉数组中刚刚加入的元素。
• step 3：然后遍历两条路径数组，依次比较元素值。
• step 4：找到两条路径第一个不相同的节点即是最近公共祖先。

代码：

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param root TreeNode类 
     * @param o1 int整型 
     * @param o2 int整型 
     * @return int整型
     */
    public int lowestCommonAncestor (TreeNode root, int o1, int o2) {
        //记录遍历到的每个节点的父节点
        Map<Integer, Integer> map = new HashMap<>();
        Queue<TreeNode> queue = new LinkedList<>();
        //由于根节点没有父节点，可以赋予一个默认值
        map.put(root.val, Integer.MIN_VALUE);
        queue.add(root);
        //直到两个节点都找到为止
        while(!map.containsKey(o1) || !map.containsKey(o2)){
            //出队
            TreeNode node = queue.poll();
            //左节点不为空，记录它的父节点，并加入到队列中
            if(node.left != null){
                map.put(node.left.val, node.val);
                queue.add(node.left);
            }
            //右节点不为空，记录它的父节点，并加入到队列中
            if(node.right != null){
                map.put(node.right.val, node.val);
                queue.add(node.right);
            }
        }
        Set<Integer> set = new HashSet<>();
        while(map.containsKey(o1)){
            set.add(o1);
            o1 = map.get(o1);
        }
        while(!set.contains(o2)){
            o2 = map.get(o2);
        }
        return o2;
    }
}

解法二：递归

思路：

• step 1：判断左子树，如果左子树为空，说明两个节点都在右子树，因此就只需要在右子树进行查找即可。
• step 2：判断右子树，如果右子树为空，说明两个节点都在左子树，因此就只需要在左子树进行查找即可。
• step 3：如果左右子树都不为空，说明两个节点分别位于左右子树上，那么返回当前结果即可。

代码：

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param root TreeNode类 
     * @param o1 int整型 
     * @param o2 int整型 
     * @return int整型
     */
       public int lowestCommonAncestor(TreeNode root, int o1, int o2) {
        return helper(root, o1, o2).val;
    }

    public TreeNode helper(TreeNode root, int o1, int o2) {
        if (root == null || root.val == o1 || root.val == o2)
            return root;
        TreeNode left = helper(root.left, o1, o2);
        TreeNode right = helper(root.right, o1, o2);
        //如果left为空，说明这两个节点在root结点的右子树上，我们只需要返回右子树查找的结果即可
        if (left == null)
            return right;
        //同上
        if (right == null)
            return left;
        //如果left和right都不为空，说明这两个节点一个在root的左子树上一个在root的右子树上，
        //我们只需要返回cur结点即可。
        return root;
    }
}