[LeetCode]: 235：Lowest Common Ancestor of a Binary Search Tree

题目：

Given a binary search tree (BST), find the lowest common ancestor (LCA) of two given nodes in the BST.

According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes v and w as the lowest node in T that has both v and w as descendants (where we allow a node to be a descendant of itself).”

        _______6______
       /              
    ___2__          ___8__
   /              /      
   0      _4       7       9
         /  
         3   5

For example, the lowest common ancestor (LCA) of nodes 2 and 8 is 6. Another example is LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition.

方法一：直接找p和q的父节点，然后比较父节点的情况来判断

代码：

    public static TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {

        if( (p.left != null && p.left.val == q.val )|| (p.right!= null && p.right.val == q.val)){
            return p;
        }
        
        if( (q.left != null && q.left.val == p.val )|| (q.right!= null && q.right.val == p.val)){
            return q;
        }
        
        if(p.val == q.val){
            return p;
        }
        
        TreeNode pFather = findFather(root,p);
        TreeNode qFather = findFather(root,q);
        
        if(pFather.val == qFather.val){
            return pFather;
        }
        
        if(pFather.val > qFather.val){
            
            return lowestCommonAncestor(root,p,qFather);
        }
        else{
            return lowestCommonAncestor(root,pFather,q);
        }
    }
    
    public static TreeNode findFather(TreeNode root, TreeNode p) {
  
        if(root == null || (root.left == null && root.right == null) ){
            System.out.println("1: null");
            return root;
        }
        
        if(root.left!= null && root.left.val == p.val ){
            System.out.println("2: " +root.left.val );
            return root;
        }
        
        if(root.right!= null && root.right.val == p.val ){
            System.out.println("3: " +root.right.val );
            return root;
        }

        if(root.val > p.val){
            return findFather(root.left,p);
        }
        else{
            return findFather(root.right,p);
        }
        
    }

小结：该方法因为递归运算多，在数据比较大的时候超时

方法二：根据BST的性质，两个节点a，b的公共袓先c一定满足a <= c <= b 或者 a >= c >= b。

代码：

    public static TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(p.val <= q.val){
            if(p.val <= root.val && root.val <= q.val){
                return root;
            }
            else{
                if(root.val >= q.val){
                    return lowestCommonAncestor(root.left,p,q);
                }
                else{
                    return lowestCommonAncestor(root.right,p,q);
                }
            }
        }
        else{
            if(q.val <= root.val && root.val <= p.val){
                return root;
            }
            else{
                if(root.val >= p.val){
                    return lowestCommonAncestor(root.left,p,q);
                }
                else{
                    return lowestCommonAncestor(root.right,p,q);
                }
            }
        }
    }

但是结果效率还不是很靠前