面试题50：二叉树中两个节点的最低公共祖先

<pre name="code" class="plain"><span style="font-size:14px;">#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;


typedef struct BtNode
{
	int value;
	struct BtNode *lchild;
	struct BtNode *rchild;
}BtNode, *Bitree;

Bitree newBtNode()
{
	Bitree p = new BtNode;

	if( NULL == p )
	{
		cout << "newBtNode func: err -1, NULL==p " << endl;
		return p;
	}

	p->value = 0;
	p->lchild = p->rchild = NULL;
	return p;
}


int createBitree( Bitree *head )
{
	int ret = 0;

	if( NULL == head )
	{
		cout << "createBitree func: err -1, NULL==head" << endl;
		ret = -1;
		return ret;
	}

	int data = 0;
	cin >> data;
	
	if( 0 == data ) // leaf
	{
		*head = NULL;
	}
	else
	{
		*head = newBtNode();
		(*head)->value = data;
		createBitree( &( (*head)->lchild ) );
		createBitree( &( (*head)->rchild ) );
	}


	return ret;
	
}

void preTravel( Bitree head )
{
	if( head != NULL )
	{
		cout << head->value << ' ';
		preTravel( head->lchild );
		preTravel( head->rchild );
	}

	return;
}

void midTravel( Bitree head )
{
	if( head != NULL )
	{
		midTravel( head->lchild );
		cout << head->value << ' ';
		midTravel( head->rchild );
	}

	return;
}

void postTravel( Bitree head )
{
	if( head != NULL )
	{
		postTravel( head->lchild );
		postTravel( head->rchild );
		cout << head->value << ' ';
	}

	return;
}

// 找出二叉树中的两个结点的最低公共祖先
Bitree findLastCommonNode( Bitree head, int value1, int value2 )
{
	Bitree pRet = NULL;

	if( NULL == head )
	{
		cout << "findLastCommonNode func: err -1, NULL==head" << endl;
		return pRet;		
	}

	
	if( ( value1 < head->value && head->value < value2 ) || ( value2 < head->value && head->value < value1 ) )
	{
		pRet = head;
		return pRet;
	}
	else if( head->value > value1 && head->value > value2 ) // 当前节点比要找的两个节点的值大，从左子树递归查找
	{
		if( NULL == head->lchild )
		{
			cout << "findLastCommonNode func: can not find the two nodes in bitree" << endl;
			return pRet;
		}
	
		return findLastCommonNode( head->lchild, value1, value2 );
	}
	else if( head->value < value1 && head->value < value2 ) // 当前节点比要找的两个节点的值小，右子树递归查找
	{
		if( NULL == head->lchild )
		{
			cout << "findLastCommonNode func: can not find the two nodes in bitree" << endl;
			return pRet;
		}

		return findLastCommonNode( head->rchild, value1, value2 );
		
	}
	
	cout << "findLastCommonNode func: err, value1 = " << value1 << ", value2 = " << value2 << endl;

	return pRet;
}


// 在二叉树中查找是否存在该节点
Bitree checkIsInBiTree( Bitree root, int value )
{
	Bitree pTarget = NULL;

	if( NULL == root )
	{	
		cout << "checkIsInBiTree( Bitree root, int value ) func: err -1, NULL==root, value = " << value << endl;
		return pTarget;
	}

	if( root->value == value )
	{
		pTarget = root;
		return pTarget;
	}
	else if( root->value < value && root->rchild != NULL )
	{
		return checkIsInBiTree( root->rchild, value );
	}
	else if( root->value > value && root->lchild != NULL )
	{
		return checkIsInBiTree( root->lchild, value );
	}
	else
	{
		return pTarget;
	}
}


int checkValid( Bitree root, int value1, int value2, Bitree *pFirstNode )
{
	int ret = 0;

	if( NULL == root || NULL == pFirstNode )
	{
		cout << " checkValid func: err -1,NULL == root || NULL == pFirstNode " << endl;
		ret = -1;
		return ret;
	}
	

	if( value1 == value2 )
	{
		Bitree p1 = checkIsInBiTree( root, value1 );

		if( NULL == p1 )
		{
			ret = -1;
			return ret;
		}
		else
		{
			Bitree p2 = NULL;

			if( p1->lchild != NULL )
			{
				p2 = checkIsInBiTree( p1->lchild, value2 );	
			}
			else if( p1->rchild != NULL )
			{
				p2 = checkIsInBiTree( p1->rchild, value2 );	
			}

			if( NULL == p2 )
			{
				ret = -1;
				return ret;
			}
			else
			{
				*pFirstNode = p1;
				ret = 1;  // value2节点是value1的子节点
			}
			
		}
	}
	else
	{
		Bitree p1 = checkIsInBiTree( root, value1 );
		Bitree p2 = checkIsInBiTree( root, value2 );

		if( NULL == p1 || NULL == p2 )
		{
			ret = -1;
			return ret;
		}

		//bool isChild = false;
		
		
		if( p1->lchild != NULL )
		{
			if( checkIsInBiTree( p1->lchild, value2 ) != NULL )
			{
				*pFirstNode = p1;
				ret = 1;	
			}
		}
		
		// 查找是否value1是value2的子节点，或value2是value1的子节点
		if( p1->rchild != NULL )
		{
			if( checkIsInBiTree( p1->rchild, value2 ) != NULL )
			{
				*pFirstNode = p1;
				ret = 1;	
			}
		}

		if( p2->lchild != NULL )
		{
			if( checkIsInBiTree( p2->lchild, value1 ) != NULL )
			{
				*pFirstNode = p2;
				ret = 1;	
			}
		}
		
		
		if( p2->rchild != NULL )
		{
			if( checkIsInBiTree( p2->rchild, value1 ) != NULL )
			{
				*pFirstNode = p2;
				ret = 1;	
			}
		}
		


	}

	return ret;
}

Bitree findParentOfChildByValue( Bitree root, int child )
{
	Bitree parent = NULL;

	if( NULL == root )
	{
		cout << "findParentOfChild func: err -1, NULL==root " << endl;
		return parent;
	}

	if( root->lchild != NULL && root->lchild->value == child )
	{
		parent = root;
		return parent;
	}	
	else if( root->rchild != NULL && root->rchild->value == child )
	{	
		parent = root;
		return parent;
	}
	else if( root->lchild != NULL && root->value > child )
	{
		return findParentOfChildByValue( root->lchild, child );
	}
	else if( root->rchild != NULL && root->value < child )
	{
		return findParentOfChildByValue( root->rchild, child );
	}
	else
	{
		return parent;
	}

}

Bitree findParentOfChildByPointer( Bitree root, Bitree child )
{
	Bitree parent = NULL;

	if( NULL == root || NULL == child )
	{
		cout << "findParentOfChildByPointer func: err -1, NULL==root || NULL == child " << endl;
		return parent;
	}

	if( root->lchild == child || root->rchild == child )
	{
		parent = root;
		return parent;
	}
	else if( root->lchild != NULL && root->value > child->value )
	{
		return findParentOfChildByPointer( root->lchild, child );
	}
	else if( root->rchild != NULL && root->value < child->value )
	{
		return findParentOfChildByPointer( root->rchild, child );
	}
	else
	{
		return parent;
	}
	
	
}
	

// 在二叉树(并不需要是排序二叉树)中查找value的节点，并返回指向该节点的指针，没找到返回NULL
Bitree getNodeByValue( Bitree root, int value )
{
	Bitree pRet = NULL;

	if( NULL == root )
	{
		cout << "getNodeByValue func: err -1, NULL==root" << endl;
		return pRet;		
	}	

	if( root->value == value )
	{
		pRet = root;
		return pRet;
	}
	else
	{
		Bitree pLeftResult = NULL;
		Bitree pRightResult = NULL;
		
		if( root->lchild != NULL )
		{
			pLeftResult = getNodeByValue( root->lchild, value );
		}

		if( pLeftResult != NULL ) // 找到了
		{
			pRet = pLeftResult;
			return pRet;
		}

		if( root->rchild != NULL )
		{
			pRightResult = getNodeByValue( root->rchild, value );
		}

		if( pRightResult != NULL ) // 找到了
		{
			pRet = pRightResult;
			return pRet;
		}
		else
		{	
			return pRet;
		}
		
		
	}

}


// 查找从根节点到pNode节点的路径
vector<Bitree> getNodePathFromRoot( Bitree root, Bitree pNode, vector<Bitree> curPath )
{
	vector<Bitree> path;

	if( NULL == root || NULL == pNode )
	{
		cout << "getNodePathFromRoot func: err -1, NULL == root || NULL == pNode" << endl;
		return path;		
	}

	if( root == pNode )
	{
		curPath.push_back( root );
		return curPath;
	}

	Bitree pleft = root->lchild;
	Bitree pright = root->rchild;
	vector<Bitree> leftResult;
	vector<Bitree> rightResult;

	curPath.push_back( root );

	if( pleft != NULL )
	{
		leftResult = getNodePathFromRoot( pleft, pNode, curPath );
	}
	
	if( pright != NULL )
	{
		rightResult = getNodePathFromRoot( pright, pNode, curPath );
	}

	if( leftResult.size() > 0 && leftResult[ leftResult.size() - 1 ] == pNode )
	{
		//cout << "find in leftTree" << endl;
		return leftResult;
	}

	if( rightResult.size() > 0 && rightResult[ rightResult.size() - 1 ] == pNode )
	{
		//cout << "find in rightTree" << endl;
		return rightResult;
	}

	return path;
}

//查找从根节点到pNode节点的路径 
//返回0表示查找成功，-1表示查找失败
int getNodePathFromRoot1( Bitree root, Bitree pNode, vector<Bitree> &path )
{
	int ret = 0; 

	if( NULL == root || NULL == pNode )
	{
		cout << "getNodePathFromRoot1 func: err -1, NULL == root || NULL == pNode" << endl;
		ret = -1;
		return ret;
	}

	if( root == pNode ) // 查找到了
	{
		path.push_back(root);
		return ret;
	}

	path.push_back(root);

	Bitree pleft = root->lchild;
	Bitree pright = root->rchild;

	int found = -1;

	if( pleft != NULL )  
	{
		int ret1 = getNodePathFromRoot1( pleft, pNode, path ); // 从左子树查找
		
		if( 0 == ret1 )
		{
			ret = ret1;
			return ret;
		}
	}

	if( pright != NULL )
	{
		int ret2 = getNodePathFromRoot1( pright, pNode, path ); // 从右子树查找
 
		if( 0 == ret2 )
		{
			ret = ret2;
			return ret;	
		}
	}

	path.pop_back(); // 左右子树都没有找到就弹出当前元素
	ret = -1;
	return ret; // 返回查找失败的标志

	
}

int main()
{
	int ret = 0;

	Bitree root = NULL;
	createBitree( &root );

	preTravel(root);
	cout << endl;

	midTravel(root);
	cout << endl;

	postTravel(root);
	cout << endl;

	cout << "============================" << endl << endl;

	int value1 = 0;
	int value2 = 0;
	Bitree pFirstNode = NULL;
/*
	while( cin >> value1 )
	{
		Bitree pNode = getNodeByValue( root, value1 );
		vector<Bitree> curPath;
		//vector<Bitree> path = getNodePathFromRoot( root, pNode, curPath );
		getNodePathFromRoot1( root, pNode, curPath );

		int len = curPath.size();
		
		for( int i = 0; i < len; ++i )
		{
			cout << curPath[i]->value << ' ';
		}
		cout << endl;
	}*/

	while( cin >> value1 >> value2 )
	{

		int status = checkValid( root, value1, value2, &pFirstNode );

		if( status < 0 )
		{
			cout << "main func: err -1, can not find " << value1 << " or " << value2 << endl;
			continue;
		}
		else if( 1 == status ) // 一个节点为另外一个节点的子节点
		{
			if( value1 == value2 )
			{

				if( root->value == value1 ) //为父亲节点
				{
					cout << "no common node with " << value1 << " and " << value2 << endl;
					continue;
				}
	
				Bitree parent = findParentOfChildByValue( root, value1 );
				
				if( parent != NULL )
				{
					cout << "common Node: " << parent->value << endl;
				}
				else
				{
					cout << "can not find common node with " << value1 << " and " << value2 << endl;
				}
				
				continue;		
			}
			else
			{
				if( root == pFirstNode )
				{
					cout << "no common node with " << value1 << " and " << value2 << endl;
					continue;
				}

				Bitree parent = findParentOfChildByPointer( root, pFirstNode );

				if( parent != NULL )
				{
					cout << "common Node: " << parent->value << endl;
				}
				else
				{
					cout << "can not find common node with " << value1 << " and " << value2 << endl;
				}

				continue;
			}
		}
		else            // status = 0
		{
			//cout << "will call findLastCommonNode" << endl;
			//cout << pFirstNode->value << endl;
			Bitree result = findLastCommonNode( root, value1, value2 );
			cout << "common Node: " << result->value << endl;
			continue;
		}
		
		
	}

	return ret;
}

/*

     10
    /  \
   5    15
  /\     /\
 3  8   12 16
/   /\  
1  6  9

./a.out 
10 5 3 1 0 0 0 8 6 0 0 9 0 0 15 12 0 0 16 0 0
10 5 3 1 8 6 9 15 12 16 
1 3 5 6 8 9 10 12 15 16 
1 3 6 9 8 5 12 16 15 10 
============================

1 3
common Node: 5
3 6
common Node: 5
3 15
common Node: 10
3 12
common Node: 10
1 16
common Node: 10
6 9
common Node: 8
3 8
common Node: 5
5 6
common Node: 10
1 2
main func: err -1, can not find 1 or 2
22 11
main func: err -1, can not find 22 or 11



*/

</span>