二叉树的公共节点

找寻二叉树中两个节点的公共父节点中最近的那个节点

情况1. 节点只有left/right，没有parent指针，root已知 情况2. root未知，但是每个节点都有parent指针 情况3. 二叉树是个二叉查找树，且root和两个节点的值(a, b)已知

 

 

虽然情况一是第一个情况，但是看上去比较复杂，我们放到最后来说，先从第二个情况开始说。

                                             10

                                          /       \
                                        6         14
                                      /  \       /　  \
                                   4   8   12 　 16

                                   /\

                                3   5

画一个二叉树来做例子。如果我们要找3和8这两个节点的公共父亲节点，我们的做法是首先找到3到根节点的路劲，然后找到8到根节点的路径。

                                             10

                                          //      \
                                        6         14
                                       / \        /　 \
                                    4   8   12 　 16

                                  /  \

                               3   5

3的路径用红色表示，8的用绿色表示，可以看到， 这里的问题实际上是另一个我们熟知的问题，有2个相交的单链表，找出它们的相交点！

只要把这个二叉树的图片倒过来看，或者把脖子倒过来看就知道了:)那个方法也是传统的求出linkedList A的长度lengthA, linkedList B的长度LengthB。然后让长的那个链表走过abs(lengthA-lengthB)步之后，齐头并进，就能解决了。

[cpp] view plain copy print ?

1. int getLength (bstNode* pNode)  
2. {     
3.     int length = 0;  
4.     bstNode* pTemp = pNode;  
5.     while (pTemp)  
6.     {  
7.         length ++ ;  
8.         pTemp = pTemp->pParent;  
9.     }  
10.     return length;  
11. }  
12. bstNode* findLCACase2(bstNode* pNode1, bstNode* pNode2)  
13. {  
14.     int length1 = getLength(pNode1);  
15.     int length2 = getLength(pNode2);  
16.       
17.     // skip the abs(length1-length2)  
18.     bstNode* pIter1 = NULL;  
19.     bstNode* pIter2 = NULL;  
20.     int k=0;  
21.     if (length1>=length2)  
22.     {  
23.         bstNode* pTemp = pNode1;  
24.         while (k++<length1-length2)  
25.         {  
26.             pTemp = pTemp->pParent;   
27.         }  
28.         pIter1 = pTemp;  
29.         pIter2 = pNode2;  
30.     }  
31.     else  
32.     {  
33.         bstNode* pTemp = pNode1;  
34.         while (k++<length2-length1)  
35.         {  
36.             pTemp = pTemp->pParent;   
37.         }  
38.         pIter1 = pNode1;  
39.         pIter2 = pTemp;  
40.     }  
41.       
42.     while (pIter1&&pIter2&&pIter1!= pIter2)  
43.     {  
44.         pIter1 = pIter1->pParent;  
45.         pIter2 = pIter2->pParent;  
46.     }  
47.     return pIter1;  
48. }  

其他地方copy的一个程序：

[cpp] view plain copy print ?

1. template<typename T>  
2. struct TreeNode1  
3. {  
4.  T data;  
5.  TreeNode1* pLChild;  
6.  TreeNode1* pRChild;  
7. };  
8.   
9. #include <vector>  
10.   
11. // 找寻节点路径，倒序，根节点在最后  
12. template<typename T>  
13. bool FindNodePath(TreeNode1<T>* pRoot, TreeNode1<T>* p, std::vector<TreeNode1<T>*>& path)  
14. {  
15.  if(pRoot == NULL)  
16.   return false;  
17.  if(p == pRoot)  
18.  {  
19.   path.push_back(pRoot);  
20.   return true  
21.  }  
22.  else if(FindNodePath(pRoot->pLChild, p, path))  
23.  {  
24.   path.push_back(pRoot->pLChild);  
25.   return true;  
26.  }  
27.  else if(FindNodePath(pRoot->pRChild, p, path))  
28.  {  
29.   path.push_back(pRoot->pRChild);  
30.   return true;  
31.  }  
32.  return false;  
33. }  
34. template<typename T>  
35. TreeNode1<T>* FindNearestParentNode(TreeNode1<T>* pRoot, TreeNode1<T>* p1, TreeNode1<T>* p2)  
36. {  
37.  std::vector<TreeNode1<T>*> path1, path2;  
38.  bool bFind = FindNodePath(pRoot, p1, path1);  
39.  bFind &= FindNodePath(pRoot, p2, path2);  
40.  if(!bFind)  
41.   return NULL;  
42.   
43.  TreeNode1<T>* pReturn = NULL;  
44.  size_t minSize = path1.size() > path2.size() ? path2.size() : path1.size();  
45.   
46. // 起始点设在可能出现共同节点的部分的起点  
47.  for(size_t i = path1.size() - minSize, j = path2.size()-minSize; i < path1.size() && j < path2.size(); ++i, ++j)  
48.  {  
49.   if(path1[i] == path2[j])  
50.   {  
51.    pReturn = path1[i];  
52.   }  
53.  }  
54.   
55.  return pReturn;  
56. }  

情况三，如果是个二叉搜索树，而且root和a, b已知，我们这个case假设a,b=3,8。从知道根这个条件我们很自然联想到递归(当然不递归也可以)地往下找。关键是收敛条件，什么情况下可以判断出当然检查的这个节点是最近父亲节点呢？其实从这个例子已经可以看出一些端倪了，如果当前访问的节点比a,b来的都小，肯定不行。如果比a,b都大，也不行。那也就是说，这个节点只有在a<=node<=b的区间内才成立(我们假定a<b这里)。这样的问题，网上广为流传着类似的代码：

[cpp] view plain copy print ?

1. #include <vector>  
2. bool nodePath (bstNode* pRoot, int value, std::vector<bstNode*>& path)  
3. {  
4.     if (pRoot==NULL) return false;  
5.     if (pRoot->data!=value)  
6.     {  
7.         if (nodePath(pRoot->pLeft,value,path))  
8.         {  
9.             path.push_back(pRoot);  
10.             return true;  
11.         }  
12.         else  
13.         {  
14.             if (nodePath(pRoot->pRight,value,path))  
15.             {  
16.                 path.push_back(pRoot);  
17.                 return true;  
18.             }  
19.             else  
20.                 return false;  
21.         }  
22.     }  
23.     else  
24.     {  
25.         path.push_back(pRoot);  
26.         return true;  
27.     }  
28. }  
29. bstNode* findLCACase1(bstNode* pNode, int value1, int value2)  
30. {  
31.     std::vector<bstNode*> path1;  
32.     std::vector<bstNode*> path2;  
33.     bool find = false;  
34.     find |= nodePath(pNode, value1, path1);  
35.     find &= nodePath(pNode, value2, path2);  
36.     bstNode* pReturn=NULL;  
37.     if (find)  
38.     {  
39.         int minSize = path1.size()>path2.size()?path2.size():path1.size();  
40.         int it1 = path1.size()-minSize;  
41.         int it2 = path2.size()-minSize;  
42.         for (;it1<path1.size(),it2<path2.size();it1++,it2++)  
43.         {  
44.             if (path1[it1]==path2[it2])  
45.             {  
46.                 pReturn = path1[it1];  
47.                 break;  
48.             }  
49.         }  
50.     }  
51.     return pReturn;  
52. }  

 

递归的方法：

只要找到这样一个节点：

已知的两个节点一个在它的左边子树，一个在它的右边子树；

或者这个节点就是已知的两个节点中的一个，而另一个恰好在它的下面。

[cpp] view plain copy print ?

1. TREE* CommonFather(TREE *root, TREE *A, TREE *B)  
2. {  
3.     if(root == NULL)  
4.         return root;  
5.     if(root == A)//如果找到A，则后面的都不再找了，如果其他分支没找到B，则B必定在A下面  
6.         return A;  
7.     if(root == B)//同上  
8.         return B;  
9.     TREE *leftChild == NULL;  
10.     TREE *rightChild == NULL;  
11.     leftChild = CommonFather(root->left, A, B);//返回A，B或结果  
12.     rightChild = CommonFather(root->right, A, B);//返回A，B或结果  
13.     if(leftChild != NULL && rightChild != NULL)//如果都不为空，则必定一个是A，一个是B；  
14.         return root;  
15.     if(leftChild != NULL)//如果不为空，则必定是A或B或结果；  
16.         return leftChild;  
17.     if(rightChild != NULL)  
18.         return rightChild;//如果不为空，则必定是A或B或结果；  
19. }  

 

令：

先比较两结点的深度，把大的先往上推，直到两结点深度一致，然后它们两就是同辈儿啦，不是兄弟就是表兄弟，往上一起推算，一直推到共同的第一个老子。

 

求a b的最近的父节点，首先求根节点到a的路径字符串，再求根节点到b的路径字符串，不用管树的构造有没有father pointer。