leetcode

题目：

Lowest Common Ancestor of a Binary Tree

 

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

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).”

        _______3______
       /              
    ___5__          ___1__
   /              /      
   6      _2       0       8
         /  
         7   4

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

分析：

求二叉树节点最低公共祖先的题目，应该做到下面两点：

1、时间复杂度O(n)，仅仅需遍历一遍二叉树。

2、要推断输入的两个节点是否在二叉树中。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
 
 struct node
 {
     TreeNode* res;
     bool bp,bq;
     node(TreeNode* n,bool x,bool y):res(n),bp(x),bq(y){}
 };
 
class Solution {
public:

    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) 
    {
         if(!root || !p || !q)
            return nullptr;
        return lowestCommonAncestor_core(root,p,q).res;
    }
     node lowestCommonAncestor_core(TreeNode* root, TreeNode* p, TreeNode* q) 
     {
         if(root==nullptr)
            return node(nullptr,false,false);
         if(root==p)
         {
             
             return hasnode(root,q)?node(root,true,true):node(root,true,false);
         }
         if(root==q)
         {
             
             return hasnode(root,p)?
node(root,true,true):node(root,false,true);
         }
         if(root->left)
         {
             auto r=lowestCommonAncestor_core(root->left,p,q);
             if(r.bp && r.bq)
                return r;
            else if(!r.bp && r.bq)
            {
                if(hasnode(root->right,p))
                    return node(root,true,true);
                else
                    return node(nullptr,false,true);
            }
            else if(r.bp && !r.bq)
            {
                if(hasnode(root->right,q))
                    return node(root,true,true);
                else
                    return node(nullptr,true,false);
            }
         }
         
        return lowestCommonAncestor_core(root->right,p,q);
             
     }
    bool hasnode(TreeNode* root, TreeNode* p)
    {
        if(root==p)
            return true;
        if(root==nullptr)
            return false;
        return hasnode(root->left,p) || hasnode(root->right,p);
    }
};