二叉树中两个节点的最近公共父节点

转载：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;
}