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 allowa 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.
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
/*algorithm
1)p or q is root, the LCA should be root
2)p and q in separated tree, LCA should be root
3)recursive call LCA algorithm for left and right tree
*/
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
if(!root)return NULL;
if(p == root || q == root)return root;
TreeNode* left = lowestCommonAncestor(root->left,p,q);
TreeNode* right = lowestCommonAncestor(root->right,p,q);
if(left && right)return root;
return left?left:right;
}
};
/*algorithm 2: path solution
1)book path from root to p,and q
2)find the last common node
memory space O(logn)
*/
bool dfs(TreeNode* root,vector<TreeNode*>&path,TreeNode* target){
if(!root)return false;
path.push_back(root);
if(root==target)return true;
TreeNode* child[]={root->left,root->right};
for(int i = 0;i < 2;i++){
if(child[i]){
if(dfs(child[i],path,target))return true;
else
path.pop_back();
}
}
return false;
}
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
if(!root)return NULL;
vector<TreeNode*>pPath,qPath;
int i,j;
bool r1 = dfs(root,pPath,p);
bool r2 = dfs(root,qPath,q);
if(!r1||!r2)return NULL;
for(i = 0,j = 0;i < pPath.size() && j < qPath.size();i++,j++){
if(pPath[i] != qPath[j])break;
}
return pPath[i-1];
}