Lowest Common Ancestor of a Binary Tree

1. 问题
   

   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.

2. 解答
   

   /**
    * Definition for a binary tree node.
    * struct TreeNode {
    *     int val;
    *     TreeNode *left;
    *     TreeNode *right;
    *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
    * };
    */
   class Solution1 {
   public:
       TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) 
       {
           if(root==NULL) return NULL;
           if(p==root || q==root) return root;
           
           TreeNode *pleft=lowestCommonAncestor(root->left,p,q);
           TreeNode *pright=lowestCommonAncestor(root->right,p,q);
           
           if(pleft!=NULL && pright!=NULL) return root;
           else if(pleft != NULL)  
               return pleft;  
           else if (pright != NULL)  
               return pright;  
           else   
               return NULL; 
        }
   };
   
   class Solution {
   public:
       TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) 
       {
           if(root==NULL) return NULL;
           if(p==root || q==root) return root;
           
           vector<TreeNode*> path1;
           vector<TreeNode*> path2;
            TreeNode *res1=NULL;
          if( GetNodePath(root,p,path1) && GetNodePath(root,q,path2))
           {
              int m=min(path1.size(),path2.size());
           for(int i=0;i<m;i++)
           {
               if(path1[i]==path2[i])
               {
                   res1=path1[i];
               }
               else
               {
                   break;
               }
           }
           }
           return res1;
        }
   
   
      
   public:
     bool GetNodePath(TreeNode* pHead, TreeNode* pNode, std::vector<TreeNode*>& path)
     {
        path.push_back(pHead);
       if(pHead == pNode)
         return true;
         
       bool found = false;
       if(pHead->left != NULL)
           found = GetNodePath(pHead->left, pNode, path);
       if(!found && pHead->right)
           found = GetNodePath(pHead->right, pNode, path);
       if(!found)
           path.pop_back();
   
       return found;
   
      }
   };