LeetCode235. 二叉搜索树的最近公共祖先

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 为不同节点且均存在于给定的二叉搜索树中。

题解 :

解题思路 : 递归每个结点 若该节点是目标结点和空 直接返回 若都不是就看其左结点和右结点是什么 若左右都不是null 依据其那面的返回条件 他们只能是p和q 那他们的祖先就是该节点了 ,若一边为空,说明p和q在一侧,所以当前结点就是其最近祖先结点

-

-

class Solution {
   public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
      if(root==p){
          return p;
      }else if(root == q){
          return q;
      }else if(root==null){
          return null;
      }

      TreeNode left = lowestCommonAncestor(root.left,p,q);
      TreeNode right = lowestCommonAncestor(root.right,p,q);

      if((left==p&&right==q)||(right==p&&left==q)){
          return root;
      }else if(left!=null){
          return left;
      }else if(right!=null){
          return right;
      }
     return null;
   }
}


//上面思路优化后写法 
class Solution {
   public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
      if(root==p||root == q||root==null){
          return root;
      }

      TreeNode rootleft = lowestCommonAncestor(root.left,p,q);
      TreeNode rootright = lowestCommonAncestor(root.right,p,q);

      if((rootleft!=null&&rootright!=null){
          //也就是一左一右一个为p一个为q的情况  那祖先不就是root么
          return root;
      }
      //返回非空的一边就是他们的祖先
     return rootleft==null?rootright:rootleft;

   }
}

还有一种简单更好理解的思路就是 建一个HashMap<TreeNode , TreeNode>用来存放每个结点的父节点 递归赋值 根节点的父节点设置为它自己 (要用来做结束条件)

完了通过一个结点 ( p或q ) 一直往上找 将父节点加到List<TreeNode>中 , 再将另一个结点一直往上找父节点遇到的结点在list中的话 该节点就是最近祖先结点

-

/**
 * 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) {
        Map<TreeNode,TreeNode> map = new HashMap<TreeNode,TreeNode>();
        //将根节点的父节点设置为自己
        map.put(root,root);
        fatherTree(root,map);

        List<TreeNode> list = new ArrayList<TreeNode>();
        
        while(p!= map.get(p)){
            list.add(p);
            p=map.get(p);
        }
        //将根节点放入 因为退到根节点就不进入循环了 所以根节点没有加入集合
        list.add(root);
        TreeNode res = null;
        while(q!=map.get(q)){
            if(list.contains(q)){
                res=q;
                break;
            }
            q=map.get(q);
        }
        //q也是遍历到根节点后不进入循环  所以当祖先是根节点时并不会被赋值res为null 
        //所以res为空时必定是root为最近祖先结点  所以 用三目运算符返回
    return res==null?root:res;
    }

    
    //创建方法 将所有的结点的父节点加入map
    public void fatherTree(TreeNode node , Map<TreeNode,TreeNode> map ){
        if(node==null){
            return;
        }
        map.put(node.left,node);
        map.put(node.right,node);
        fatherTree(node.left,map);
        fatherTree(node.right,map);
    }
        
}