二叉樹是搜尋二叉樹

1、原理：二叉搜尋樹是排序過的 ，位於左子樹的結點都比父結點小，位於右子樹的結點都比父結點大，我們只需從根節點開始和兩個輸入的結點進行比較，如果當前節點的值比兩個結點的值都大，那麼最低的公共祖先結點一定在該結點的左子樹中，下一步開遍歷當前結點的左子樹。如果當前節點的值比兩個結點的值都小，那麼最低的公共祖先結點一定在該結點的右子樹中，下一步開遍歷當前結點的右子樹。這樣從上到下找到第一個在兩個輸入結點的值之間的結點。

2、實現程式碼

BinaryNode* CreateBinaryTree(int* array, int length)
{
	BinaryNode* root = new BinaryNode(array[0]);
	BinaryNode* pTemp = NULL;
	for (int idx = 1; idx < length; idx++)
	{
		BinaryNode* pCur = root;
		//尋找插入位置
		while (pCur)
		{
			if (array[idx]<pCur->_value)
			{
				pTemp = pCur;
				pCur = pCur->_left;
			}
			else if (array[idx]>pCur->_value)
			{
				pTemp = pCur;
				pCur = pCur->_right;
			}
			else
				return NULL;
		}
		//插入元素
		pCur = new BinaryNode(array[idx]);
		if (array[idx] < pTemp->_value)
			pTemp->_left = pCur;
		else
			pTemp->_right = pCur;
	}
	return root;
}

//搜素二叉樹尋找最近公共祖先節點
BinaryNode* AncestorTreeNode(BinaryNode* pRoot, BinaryNode* node1, BinaryNode* node2)
{
	if (pRoot == NULL)
		return NULL;
	if (node1 == NULL)
		return node2;
	if (node2 == NULL)
		return node1;
	while (pRoot)
	{
		if (pRoot->_value > node1->_value && pRoot->_value > node2->_value)
			pRoot = pRoot->_left;
		if (pRoot->_value < node1->_value && pRoot->_value < node2->_value)
			pRoot = pRoot->_right;
		else
			return pRoot;
	}
	return NULL;
}
 

測試用例：

void FunTest1()
{
	BinaryNode* pRoot = NULL;
	int array[] = { 5, 2, 6 };
	int length = sizeof(array) / sizeof(array[0]);
	pRoot = CreateBinaryTree(array, length);
	BinaryNode* node1 = pRoot->_left->_left;
	BinaryNode* node2 = pRoot->_left->_right;
    BinaryNode* pNode = AncestorTreeNode(pRoot, node1, node2);
	if (pNode)
		cout << pNode->_value << endl;
}
 

二叉樹節點中包含指向父節點的指標

1、原理：如果樹中每個結點都有父結點（根結點除外），這個問題可以轉換成求兩個連結串列的第一個公共結點，假設樹結點中指向父結點的指標是parent，樹的每一個葉結點開始都由一個指標parent串起來的連結串列，每個連結串列的尾結點就是樹的根結點。那麼輸入的這兩個結點位於連結串列上，它們的最低公共祖先結點剛好是這兩個連結串列的第一個公共結點。 2、實現程式碼

int Hight(BinaryNode* root, BinaryNode* node)
{
	int len = 0;
	while (node)
	{
		len++;
		node = node->_parent;
	}
	return len;
}
BinaryNode* GetLastCommonAncestor(BinaryNode* root, BinaryNode* node1, BinaryNode* node2)
{

	if (root == NULL || node1 == NULL || node2 == NULL)
		return NULL;

	int len1 = Hight(root, node1);//一個連結串列的高度
	int len2 = Hight(root, node2);//另一個連結串列的高度
	//尋找兩個連結串列的第一個交點
	while (len1 != len2)
	{
		if (len1 < len2)
			len2--;
		else
			len1--;
	}

	while (node1 && node2 && node1 != node2)
	{
		node1 = node1->_parent;
		node2 = node2->_parent;
	}

	if (node1 == node2)
		return node1;
	else
		return NULL;
}
 

測試用例

void FunTest()
{
	BinaryNode* root = new BinaryNode(1);
	BinaryNode* cur = root;
	queue<BinaryNode*> q;
	BinaryNode* top = NULL;

	q.push(root);
	for (int i = 2; i <= 7; i++)
	{
		if (!q.empty())
		{
			top = q.front();
			if (cur == top->_left)
			{
				cur = new BinaryNode(i);
				top->_right = cur;
				cur->_parent = top;
				q.pop();
			}
			else
			{
				cur = new BinaryNode(i);
				top->_left = cur;
				cur->_parent = top;
			}
			q.push(cur);
		}
	}
	BinaryNode* node1 = root->_left->_left;
	BinaryNode* node2 = root->_left->_right;
	BinaryNode* ancestor = GetLastCommonAncestor(root, node1, node2);
	if (ancestor)
		cout << ancestor->_value << endl;
	else
		cout << "沒有公共祖先" << endl;
}

二叉樹是普通二叉樹， 沒有指向父結點的指標

1、原理：在二叉樹根結點 的左子樹和右子樹中分別找輸入的兩個結點，如果兩個結點都在左子樹，遍歷當前結點的左子樹，如果兩個結點都在右子樹，遍歷當前結點的右子樹，直到一個在當前結點的左子樹，一個在當前結點的右子樹，返回當前結點就是最低的公共祖先結點。 2、實現程式碼

bool IsNodeInTree(BinaryNode* pRoot, BinaryNode* pNode)
{
	if (pRoot == NULL || pNode == NULL)
		return false;
	if (pNode == pRoot)
		return true;
	if (IsNodeInTree(pRoot->_left, pNode) || IsNodeInTree(pRoot->_right, pNode))
		return true;
	return false;
}
BinaryNode* GetCommonAncestor(BinaryNode* pRoot, BinaryNode* node1, BinaryNode* node2)
{
	if (pRoot == NULL)
		return NULL;
	if (node1 == pRoot && IsNodeInTree(pRoot, node2) || node2 == pRoot && IsNodeInTree(pRoot, node1))
		return pRoot;

	bool node1left = IsNodeInTree(pRoot->_left, node1);
	bool node1right = IsNodeInTree(pRoot->_right, node1);
	bool node2left = IsNodeInTree(pRoot->_left, node2);
	bool node2right = IsNodeInTree(pRoot->_right, node2);
	if (node1left && node2right || node1right && node2left)
		return pRoot;
	if (node1left && node2left)
		return GetCommonAncestor(pRoot->_left, node1, node2);
	if (node1right && node2right)
		return GetCommonAncestor(pRoot->_right, node1, node2);
	return NULL;
}

測試用例

void FunTest3()
{
	BinaryNode* root = new BinaryNode(1);
	BinaryNode* cur = root;
	queue<BinaryNode*> q;
	BinaryNode* top = NULL;

	q.push(root);
	for (int i = 2; i <= 7; i++)
	{
		if (!q.empty())
		{
			top = q.front();
			if (cur == top->_left)
			{
				cur = new BinaryNode(i);
				top->_right = cur;
				cur->_parent = top;
				q.pop();
			}
			else
			{
				cur = new BinaryNode(i);
				top->_left = cur;
				cur->_parent = top;
			}
			q.push(cur);
		}
	}
	BinaryNode* node1 = root->_left->_left;
	BinaryNode* node2 = root->_left->_right;
	BinaryNode* ancestor = GetCommonAncestor(root, node1, node2);
	if (ancestor)
		cout << ancestor->_value << endl;
	else
		cout << "沒有公共祖先" << endl;
}

標頭檔案和結點的結構體

#include<iostream>
#include<queue>
using namespace std;

struct BinaryNode
{
	BinaryNode* _left;
	BinaryNode* _right;
	BinaryNode* _parent;
	int _value;

	BinaryNode(const int& value)
		:_value(value)
		, _left(NULL)
		, _right(NULL)
		, _parent(NULL)
	{}
};