剑指Offer——面试题68：树中两个结点的最低公共祖先

面试题68：树中两个结点的最低公共祖先

题目：输入两个树结点，求它们的最低公共祖先。

一：若树为二叉搜索树

#include<iostream>
#include<algorithm>
#include<vector> 
using namespace std;
struct TreeNode{
	int Value;
	TreeNode* left;
	TreeNode* right; 
};
TreeNode* GetLastCommonParent(TreeNode* pRoot, TreeNode* pNode1, TreeNode* pNode2){
	if(TreeNode==NULL || pNode1==NULL || pNode2==NULL) return NULL;
	
	if(pRoot->Value>pNode1->Value && pRoot->Value>pNode2->Value) return GetLastCommonParent(pRoot->left, pNode1, pNode2);
	
	if(pRoot->Value<pNode1->Value && pRoot->Value<pNode2->Value) return GetLastCommonParent(pRoot->right, pNode1, pNode2);
	
	return pRoot;
}
int main(){
	return 0;
} 

二：若树为普通的树，有指向父节点的指针

#include<iostream>
#include<algorithm>
#include<vector> 
using namespace std;
struct TreeNode{
	int Value;
	vector<TreeNode*> Children;
	TreeNode* Parent; 
};
unsigned int GetListLength(TreeNode* pNode){
	unsigned int nLen=0;
	TreeNode* pTemp=pNode;
	while(pTemp!=NULL){
		nLen++;
		pTemp=pTemp->Parent;
	}
	return nLen;
}
// 可以转换成 两个链表的第一个公共节点 
TreeNode* GetLastCommonParent(TreeNode* pNode1, TreeNode* pNode2){
	if(pNode1==NULL || pNode2==NULL) return NULL; 
	
	// 得到两个链表的长度
	unsigned int len1=GetListLength(pNode1);
	unsigned int len2=GetListLength(pNode2);
	int nlengthDiff=len1-len2;
	
	TreeNode* pListHeadLong=pNode1;
	TreeNode* pListHeadShort=pNode2;
	if(len1<len2){
		pListHeadLong=pNode2;
		pListHeadShort=pNode1;
		nlengthDiff=len2-len1;
	}
	
	for(int i=0;i<nlengthDiff;i++) pListHeadLong=pListHeadLong->Parent;
	
	while(pListHeadLong!=NULL && pListHeadShort!=NULL && pListHeadLong!=pListHeadShort){
		pListHeadLong=pListHeadLong->Parent;
		pListHeadShort=pListHeadShort->Parent;
	}
	
	TreeNode* p=pListHeadLong;
	return p;
}
int main(){
	return 0;
} 

三：若树为普通的树，没有指向父节点的指针

#include<iostream>
#include<algorithm>
#include<vector> 
using namespace std;
struct TreeNode{
	int Value;
	vector<TreeNode*> Children;    
};
bool GetNodePath(TreeNode* pRoot, TreeNode* pNode, list<TreeNode*>& path){ // 获取路径 
	if(pRoot==NULL) return true;
	
	path.push_back(pRoot);
	
	bool found=false;
	
	vector<TreeNode*>::iterator it=pRoot->Children.begin();
	while(!found && it!=pRoot->Children.end()){
		found=GetNodePath(*it, pNode, path);
		it++;
	}
	if(!found) path.pop_back();
	return found;
} 

TreeNode* GetLastCommonNode(const list<TreeNode*>& path1, const list<TreeNode*>& path2){
	list<TreeNode*>::const_iterator it1=path1.begin();
	list<TreeNode*>::const_iterator it2=path2.begin();
	
	TreeNode* pLast=NULL;
	
	while(it1!=path1.end() && it2!=path2.end()){
		if(*it1==*it2) pLast=*it1;
		
		it1++;
		it2++;
	}
	return pLast;
} 

TreeNode* GetLastCommonParent(TreeNode* pRoot, TreeNode* pNode1, TreeNode* pNode2){
	if(pRoot==NULL || pNode1==NULL || pNode2==NULL) return NULL;
	
	list<TreeNode*> path1;
	GetNodePath(pRoot, pNode1, path1);
	
	list<TreeNode*> path2;
	GetNodePath(pRoot, pNode2, path2);
	
	return GetLastCommonNode(path1, path2);
}
int main(){
	return 0;
}