树中两个节点的最低公共父节点

题目：给出两个结点A和B，求解这两个结点的最低公共祖先（LCA）

条件（1）树为二叉搜索树

思路：

二叉搜索树指的是每个父节点有两个子节点，并且节点的左子树均小于节点值，右子树上节点的值大于节点的值。

所以我们求两个节点的最低公共父节点应满足（父节点大于其中一个节点且小于另外一个。）如果此时搜索的节点大于这两个节点，则最低父节点应在该节点的左子树中，相反的，此时搜索的节点小于这两个节点，则最低父节点应在该节点的右子树中。具体节点定义和实现方法如下：

struct TreeNode
{
	int value;
	TreeNode * left;
	TreeNode * right;
};

TreeNode* FindNearestFather(TreeNode* root,TreeNode* node1,TreeNode* node2)
{
	if(root&&node1&&node2)
	{
		if(root->val > node1->value&&root->val < node2->value)
			return root;
		else if(root->val > node1->value&&root->val > node2->value)
			return FindNearestFather(root->left,node1,node2);
		else if(root->val < node1->value&&root->val < node2->value)
			return FindNearestFather(root->right,node1,node2);
		else
			;
	}
	return NULL;
}

条件（2）一般的二叉树 + 有指向父亲的指针

一般的二叉树，大小没有规律，但是有指向父节点的指针，这就好办多了，相当于每个节点多了一个指向父节点的属性。我们可以从两个节点往回搜索，找到到根节点的两条路径，最后只要找这两条路径的第一个公共节点即可。和找两链表的第一个公共节点相同的处理办法。树节点定义和算法实现如下：

struct TreeNode1
{
	int value;
	TreeNode1 * father;
	TreeNode1 * left;
	TreeNode1 * right;
};
int countLen(TreeNode1 *root)
{
	int len=0;
	while(root)
	{
	  root=root->father;
	  len++;
	}
	return len;
}
TreeNode1* FindNearestFather1(TreeNode1* root,TreeNode1* node1,TreeNode1* node2)
{
	if(root&&node1&&node2)
	{
		TreeNode1* n1=node1;
		TreeNode1* n2=node2;
		int length1=countLen(n1);
		int length2=countLen(n2);
		n1=node1;
		n2=node2;
		if(length1>length2)
		{
			int len=length1-length2;
			while(len)
			{
				n1=n1->father;
			}
		}
		else if(length1<length2)
		{
			int len=length2-length1;
			while(len)
			{
				n2=n2->father;
			}
		}
		else
			;
		while(n1!=n2)
		{
			n1=n1->father;
			n2=n2->father;
		}
		return n1;
	}
	return NULL;
}

条件（3）一般的树且没有指向父亲的指针

一般的树，每个节点的子节点个数可以不一样。那么我们就用通用的方法，找到由根节点到两个节点的路径，然后找这两个路径的最后一个公共节点即可。关键是保存遍历路径，我们采用前向遍历的方法，先遍历根节点，再依次遍历每个子节点。代码如下：

struct TreeNode2
{
	int value;
	vector<TreeNode2*> Children;
};
bool GetPath(TreeNode2* root,TreeNode2* node,vector<TreeNode2*>& path)//前向遍历
{
	if(root==node)
		return true;
	path.push_back(root);//找到根节点，相当于打印出来
	bool flag=false;
	vector<TreeNode*>::iterator iter=root->Children.begin();
	while(!found&&iter!=root->Children.end())
	{
		found=GetPath(*iter,node,path);//挨个深度（前向）遍历子节点
		iter++;
	}
	if(!found)
		path.pop_back();//不是该路径则输出最尾元素
	return found;
}
TreeNode2 * LastCommonFather(const vector<TreeNode2*>&path1,const vector<TreeNode2*>&path2)
{
	vector<TreeNode2*>::const_iterator iter1=path1.begin();
	vector<TreeNode2*>::const_iterator iter2=path2.begin();
	TreeNode2* last=NULL;
	while(iter1!=path1.end()&&iter2!=path2.end())
	{
		if(*iter1==*iter2)
			last=*iter1;
		iter1++;
		iter2++;
	}
	return last;
}
TreeNode2* FindNearestFather2(TreeNode2* root,TreeNode2* node1,TreeNode2* node2)
{
	if(root&&node1&&node2)
	{
		vector<TreeNode*> path1;
		vector<TreeNode*> path2;
		if(!GetPath(root,node1,path1)) return NULL;
		if(!GetPath(root,node2,path2)) return NULL;
		return LastCommonFather(path1,path2);
	}
	return NULL;
}