转载:http://blog.csdn.net/hackbuteer1/article/details/8022138#
这个问题可以分为四种情况来考虑:
情况一:root未知,但是每个节点都有parent指针
此时可以分别从两个节点开始,沿着parent指针走向根节点,得到两个链表,然后求两个链表的第一个公共节点,这个方法很简单,不需要详细解释的。
情况二:节点只有左、右指针,没有parent指针,root已知
思路:有两种情况,一是要找的这两个节点(a, b),在要遍历的节点(root)的两侧,那么这个节点就是这两个节点的最近公共父节点;
二是两个节点在同一侧,则 root->left 或者 root->right 为 NULL,另一边返回a或者b。那么另一边返回的就是他们的最小公共父节点。
递归有两个出口,一是没有找到a或者b,则返回NULL;二是只要碰到a或者b,就立刻返回。
说明:这个递归的解法是不完整的,对于a,b不全在二叉树中的情况,并没有考虑到。
// 二叉树结点的描述
struct Node
{
int data;
Node *lchild, *rchild; // 左右孩子
Node(int x):data(x),lchild(NULL),rchild(NULL){}
};
// 节点只有左指针、右指针,没有parent指针,root已知
Node* findLowestCommonAncestor(Node* root , Node* a , Node* b){
if(root==NULL)
return NULL;
if(root==a||root==b)
return root;
Node* left = findLowestCommonAncestor(root->lchild,a,b);
Node* right= findLowestCommonAncestor(root->rchild,a,b);
if(left&&right)
return root;
return left?left:right;
}
int main(){
Node* v15 = new Node(15);
Node* v8 = new Node(8);
Node* v25 = new Node(25);
Node* v30 = new Node(30);
v15->lchild = v8;
v15->rchild = v25;
auto res = findLowestCommonAncestor(v15,v8,v30);
cout<<res->data<<endl;
}
情况三: 二叉树是个二叉查找树,且root和两个节点的值(a, b)已知
//二叉树结点的描述
struct Node{
int data;
Node *lchild, *rchild; // 左右孩子
Node(int x):data(x),lchild(NULL),rchild(NULL){}
};
//待查找的是排序二叉搜索树
Node* findLowestCommonAncestor(Node* root , Node* a , Node* b){
if(root==NULL)
return root;
int min = a->data < b->data ? a->data:b->data;
int max = a->data > b->data ? a->data:b->data;
while(root){
if(root->data>min && root->data < max)
return root;
if(root->data > min && root->data > max)
root = root->lchild;
else
root = root->rchild;
}
return NULL;
}
int main(){
Node* v15 = new Node(15);
Node* v8 = new Node(8);
Node* v25 = new Node(25);
Node* v30 = new Node(30);
Node* v7 = new Node(7);
Node* v9 = new Node(9);
Node* v20 = new Node(20);
v15->lchild = v8;
v15->rchild = v25;
v25->lchild = v20;
v25->rchild = v30;
v8->lchild = v7;
v8->rchild = v9;
auto res = findLowestCommonAncestor(v15,v20,v30);
cout<<res->data<<endl;
}
情况四:上述的适用于二叉树,但是如果给的树不是二叉树。那么有个通用的解法,就是将根结点到目标结点的路径先保存下来。然后,再去寻找公共的父节点。时间复杂度O(n)。
//二叉树结点的描述
struct Node{
int data;
Node *lchild, *rchild; // 左右孩子
Node(int x):data(x),lchild(NULL),rchild(NULL){}
};
//寻找从根结点到父节点的path
bool GetNodePath(Node* root,Node* target,vector<Node*>& path){
if(root==NULL)
return false;
if(root == target)
return true;
path.push_back(root);
bool found = false;
if(!found) found = GetNodePath(root->lchild,target,path);
if(!found) found = GetNodePath(root->rchild,target,path);
if(!found) path.pop_back();
return found;
}
//寻找最近的公共父节点
Node* GetLastCommonNode(const vector<Node*>& path1,const vector<Node*>& path2){
int len1 = path1.size();
int len2 = path2.size();
int len = len1 < len2 ? len1:len2;
Node* LastCommon = NULL;
for(int i=0;i<len;i++){
if(path1[i]==path2[i])
LastCommon = path1[i];
else
break;
}
return LastCommon;
}
//寻找最小公共父节点
Node* GetLastCommonParent(Node* root,Node* pNode1,Node* pNode2){
if(root==NULL||pNode1==NULL||pNode2==NULL)
return NULL;
vector<Node*> path1;
bool flag1= GetNodePath(root,pNode1,path1);
vector<Node*> path2;
bool flag2= GetNodePath(root,pNode2,path2);
if(flag1&&flag2)
return GetLastCommonNode(path1,path2);
else
return NULL;
}