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

题目：求二叉树中两个节点的最近公共祖先节点

一、该二叉树为搜索二叉树

搜索二叉树的特点：

任意一个节点的左子树的所有节点值都比该节点的值小，其右子树的所有节点值都比该节点的值大。

解决该问题方法：

从树的根节点开始和两个节点作比较，如果当前节点的值比两个节点的值都大，则这两个节点的最近公共祖先节点一定在该节点的左子树中，则下一步遍历当前节点的左子树；

如果当前节点的值比两个节点的值都小，则这两个节点的最近公共祖先节点一定在该节点的右子树中，下一步遍历当前节点的右子树；这样直到找到第一个值是两个输入节点之间的值的节点，该节点就是两个节点的最近公共祖先节点。

如图：

二、该二叉树为一般二叉树，有二叉树节点中包含指向父节点的指针

二叉树节点结构（含父节点）：

[cpp]  view plain  copy

 

1. struct BinaryNode  
2. {  
3.     BinaryNode* _left;  
4.     BinaryNode* _right;  
5.     BinaryNode* _parent;  
6.     int _value;  
7.   
8.     BinaryNode(const int& value)  
9.         :_value(value)  
10.         , _left(NULL)  
11.         , _right(NULL)  
12.         , _parent(NULL)  
13.     {}  
14. };  

方法一：

首先给出node1的父节点node1->_parent，然后将node1的所有父节点依次和node2->parent作比较，如果发现两个节点相等，则该节点就是最近公共祖先，直接将其返回。如果没找到相等节点，则将node2的所有父节点依次和node1->_parent->_parent作比较......直到node1->_parent==NULL。

代码如下：

[cpp]  view plain  copy

 

1. BinaryNode * GetLastCommonAncestor(BinaryNode * root, BinaryNode * node1, BinaryNode * node2)  
2. {  
3.     BinaryNode * temp;  
4.     while (node1 != NULL)  
5.     {  
6.         node1 = node1->_parent;  
7.         temp = node2;  
8.         while (temp != NULL)  
9.         {  
10.             if (node1 == temp->_parent)  
11.                 return node1;  
12.             temp = temp->_parent;  
13.         }  
14.     }  
15. }  

该算法时间复杂度为O(n^2)，可用另一种O(n)的算法

方法二：

给定的两个节点都含有父节点，因此，可将这两个节点看做是两个链表的头结点，将求两个节点的最近公共祖先节点转化为求两链表的交点，这两个链表的尾节点都是根节点。

如图：

若查找节点G, H的最近公共祖先节点可转化为如图所示的两个链表的交点，可知两节点最近公共祖先节点为B。

代码如下：

[cpp]  view plain  copy

 

1. int Hight(BinaryNode* root, BinaryNode* node)  
2. {  
3.     int len = 0;  
4.     for (; node != NULL; node = node->_parent)  
5.         len++;  
6.   
7.     return len;  
8. }  

[cpp]  view plain  copy

 

1. BinaryNode* GetLastCommonAncestor(BinaryNode* root, BinaryNode* node1, BinaryNode* node2)  
2. {  
3.   
4.     if (root == NULL || node1 == NULL || node2==NULL)  
5.         return NULL;  
6.   
7.     int len1 = Hight(root,node1);  
8.     int len2 = Hight(root,node2);  
9.       
10.   
11.     for (; len1 > len2; len1--)  
12.         node1 = node1->_parent;  
13.     for (; len2 > len1; len2--)  
14.         node2 = node2->_parent;  
15.   
16.     while (node1 && node2 && node1 != node2)  
17.     {  
18.         node1 = node1->_parent;  
19.         node2 = node2->_parent;  
20.     }  
21.       
22.     if (node1 == node2)  
23.         return node1;  
24.     else  
25.         return NULL;  
26. }  

三、该二叉树为一般二叉树，有二叉树节点中没有指向父节点的指针

方法一：

1) 找到从根到node1的路径，并存储在一个向量或数组中。
2)找到从根到node2的路径，并存储在一个向量或数组中。
3) 遍历这两条路径，直到遇到一个不同的节点，则前面的那个即为最低公共祖先.

如图，若查找节点G, H的最近公共祖先节点可转化为如图所示的两个数组中的最后一个相同的节点，可知两节点最近公共祖先节点为B。

方法二：

上面的方法虽然是O(n)，但是操作依然繁琐，并且需要额外的空间来存储路径。

从根节点开始遍历，如果node1和node2中的任一个和root匹配，那么root就是最低公共祖先。 如果都不匹配，则分别递归左、右子树，如果有一个 节点出现在左子树，并且另一个节点出现在右子树，则root就是最低公共祖先.  如果两个节点都出现在左子树，则说明最低公共祖先在左子树中，否则在右子树。

若求G， H节点的最近公共祖先节点，在B的左子书中找到G, B的右子树中返回H，得到G,H的最低公共祖先B。

代码如下：

[cpp]  view plain  copy

 

1. BinaryNode* GetLastCommonAncestor(BinaryNode* root, BinaryNode* node1, BinaryNode* node2)  
2. {  
3.     if (root == NULL || node1 == NULL || node2 == NULL)  
4.         return NULL;  
5.   
6.     if (node1 == root || node2 == root)  
7.         return root;  
8.   
9.     BinaryNode* cur = NULL;  
10.   
11.     BinaryNode* left_lca = GetLastCommonAncestor(root->_left, node1, node2);  
12.     BinaryNode* right_lca = GetLastCommonAncestor(root->_right, node1, node2);  
13.     if (left_lca && right_lca)  
14.         return root;  
15.     if (left_lca == NULL)  
16.         return right_lca;  
17.     else  
18.         return left_lca;  
19. }  

该函数当一个节点是另一个节点的祖先时，返回的是离根节点最近的那个节点，要想返回最近公共祖先节点需进行判断两节点是否有祖孙关系，参考代码如下：

简要说明：若两节点为F,D，则判断出B的左子树中的D节点后，继续判断判断节点D的左右子树中是否含有节点F，若有，则返回B，若没有则继续判断右子树中的另一个节点。

参考代码如下：

[cpp]  view plain  copy

 

1. BinaryNode* GetLastCommonAncestor(BinaryNode* root, BinaryNode* node1, BinaryNode* node2)  
2. {  
3.     if (root == NULL || node1 == NULL || node2 == NULL)  
4.         return NULL;  
5.   
6.     if (node1 == root || node2 == root)  
7.         return root;  
8.       
9.     BinaryNode* cur = NULL;  
10.   
11.     BinaryNode* left_lca = GetLastCommonAncestor(root->_left,node1,node2);  
12.     if (NULL != left_lca)  
13.     {  
14.         cur = GetLastCommonAncestor(left_lca->_left, node1, node2);  
15.         if (cur ==NULL)  
16.            cur = GetLastCommonAncestor(left_lca->_right, node1, node2);  
17.         if ((cur == node1) && (left_lca == node2) || (cur == node2) && (left_lca == node1))  
18.             return root;  
19.     }  
20.     BinaryNode* right_lca = GetLastCommonAncestor(root->_right, node1, node2);  
21.     if (NULL != right_lca)  
22.     {  
23.         cur = GetLastCommonAncestor(right_lca->_left, node1, node2);  
24.         if (cur == NULL)  
25.             cur = GetLastCommonAncestor(right_lca->_right, node1, node2);  
26.         if ((cur == node1) && (left_lca == node2) || (cur == node2) && (left_lca == node1))  
27.             return root;  
28.     }  
29.     if (left_lca && right_lca)  
30.         return root;  
31.     if (left_lca == NULL)  
32.         return right_lca;  
33.     else  
34.         return left_lca;  
35. }  

测试用例：

[cpp]  view plain  copy

 

1. void Test()  
2. {  
3.     BinaryNode* root = new BinaryNode(1);  
4.   
5.     BinaryNode* cur = root;  
6.     queue<BinaryNode*> q;  
7.     BinaryNode* top = NULL;  
8.   
9.     q.push(root);  
10.     for (int i = 2; i <= 7; i++)  
11.     {  
12.         if (!q.empty())  
13.         {  
14.             top = q.front();  
15.             if (cur == top->_left)  
16.             {  
17.                 cur = new BinaryNode(i);  
18.                 top->_right = cur;  
19.                 cur->_parent = top;  
20.                 q.pop();  
21.             }  
22.             else  
23.             {  
24.                 cur = new BinaryNode(i);  
25.                 top->_left = cur;  
26.                 cur->_parent = top;  
27.             }  
28.             q.push(cur);  
29.         }  
30.     }  
31.     BinaryNode* node1 = root->_left->_left;  
32.     BinaryNode* node2 = root->_left->_right;  
33.     BinaryNode* ancestor = GetLastCommonAncestor(root, node1, node2);  
34.     if (ancestor)  
35.         cout << ancestor->_value << endl;  
36.     else  
37.         cout << "没有公共祖先" << endl;  
38. }  

                      测试用例二叉树

可分别用包含父节点和不包含父节点的方法进行测试。