寻找二叉树中两个子节点的最近父节点
2013-05-04 11:01
246 查看
参考一：
情况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)步之后，齐头并进，就能解决了。
int getLength (bstNode* pNode)
{
int length = 0;
bstNode* pTemp = pNode;
while (pTemp)
{
length ++ ;
pTemp = pTemp->pParent;
}
return length;
}
bstNode* findLCACase2(bstNode* pNode1, bstNode* pNode2)
{
int length1 = getLength(pNode1);
int length2 = getLength(pNode2);
// skip the abs(length1-length2)
bstNode* pIter1 = NULL;
bstNode* pIter2 = NULL;
int k=0;
if (length1>=length2)
{
bstNode* pTemp = pNode1;
while (k++<length1-length2)
{
pTemp = pTemp->pParent;
}
pIter1 = pTemp;
pIter2 = pNode2;
}
else
{
bstNode* pTemp = pNode2;
while (k++<length2-length1)
{
pTemp = pTemp->pParent;
}
pIter1 = pNode1;
pIter2 = pTemp;
}
while (pIter1&&pIter2&&pIter1!= pIter2)
{
pIter1 = pIter1->pParent;
pIter2 = pIter2->pParent;
}
return pIter1;
}
自己写了个代码，总觉得有些拖沓冗余，希望有缘人看到文章之后能帮我改写的更和谐一些。
还是原来这个图，情况三，如果是个二叉搜索树，而且root和a, b已知，我们这个case假设a,b=3,8。从知道根这个条件我们很自然联想到递归(当然不递归也可以)地往下找。关键是收敛条件，什么情况下可以判断出当然检查的这个节点是最近父亲节点呢？其实从这个例子已经可以看出一些端倪了，如果当前访问的节点比a,b来的都小，肯定不行。如果比a,b都大，也不行。那也就是说，这个节点只有在a<=node<=b的区间内才成立(我们假定a<b这里)。这样的问题，网上广为流传着类似的代码：
bstNode* findLCACase3(bstNode* pNode, int value1, int value2)
{
bstNode* pTemp = pNode;
while (pTemp)
{
if (pTemp->data>value1 && pTemp->data>value2)
pTemp = pTemp->pLeft;
else if(pTemp->data<value1 && pTemp->data<value2)
pTemp = pTemp->pRight;
else
return pTemp;
}
return NULL;
}
好，前面的问题都解决了，我们再回过头来看第一个情况，只有ROOT和left, right节点，没有parent也不是排序树，怎么办？网络上也流传着很多所谓的LCA,RMQ算法，我们不暇找个最合适的，尤其是在面试的时候，特定时间空间下你很难写出一个逻辑非常复杂的东西(比如你会在面试的时候去实现一个Suffix Tree还是用动态规划来求最长公共子串，哪怕效率不同，我也选择动态规划:))。所以这里，碰到类似的问题的时候，我选择简单的记录找到node1和node2的路径，然后再把它们的路径用类似的情况二来做分析，比如还是node1=3,node2=8这个case.我们肯定可以从根节点开始找到3这个节点，同时记录下路径3,4,6,10，类似的我们也可以找到8,6,10。我们把这样的信息存储到两个vector里面，把长的vector开始的多余节点3扔掉，从相同剩余长度开始比较，4!=8,
6==6, coooool,我们找到了我们的答案。下面的代码完全按照这个思路写成
#include <vector>
bool nodePath (bstNode* pRoot, int value, std::vector<bstNode*>& path)
{
if (pRoot==NULL) return false;
if (pRoot->data!=value)
{
if (nodePath(pRoot->pLeft,value,path))
{
path.push_back(pRoot);
return true;
}
else
{
if (nodePath(pRoot->pRight,value,path))
{
path.push_back(pRoot);
return true;
}
else
return false;
}
}
else
{
path.push_back(pRoot);
return true;
}
}
bstNode* findLCACase1(bstNode* pNode, int value1, int value2)
{
std::vector<bstNode*> path1;
std::vector<bstNode*> path2;
bool find = false;
find |= nodePath(pNode, value1, path1);
find &= nodePath(pNode, value2, path2);
bstNode* pReturn=NULL;
if (find)
{
int minSize = path1.size()>path2.size()?path2.size():path1.size();
int it1 = path1.size()-minSize;
int it2 = path2.size()-minSize;
for (;it1<path1.size(),it2<path2.size();it1++,it2++)
{
if (path1[it1]==path2[it2])
{
pReturn = path1[it1];
break;
}
}
}
return pReturn;
}
参考二：
二叉树的节点定义为如下：
typedef struct Node{
int value;
struct Node *Left;
struct Node *Right;
}*PNode;
分析：若节点q1,q2均在root的左子树中，则其最低父节点必定也在做左子树，若均在root的右子树中，同理其父节点在右子树中。若分别存在于root的左右子树中，则当前节点root就是q1,q2的最近父节点。
首先设置一个函数来判断节点q是否包含在root的子树中。根据二叉树的性质可得到如下函数：
bool Judge(PNode p1,PNode p2) //判断p2是否包含在p1的子树中包括p1
{
if(!p1||!p2)
return false;
if(p1->value ==p2->value )
return true;
bool temp=false;
if(p2->value <p1->value ) //小于根节点值，则去左子树寻找
temp=Judge(p1->Left ,p2);
else
temp=Judge(p1->Right ,p2);
return temp;
}
由上述分析以及判断函数可以得到如下代码：
void Find(PNode root,PNode p1,PNode p2) //在以root为根的二叉树中寻找p1,p2节点的最近父节点
{
bool l1,l2,r1,r2;
l1=false;
l2=false;
r1=false;
r2=false;
if(root->Left )
{
l1=Judge(root->Left ,p1);
l2=Judge(root->Left ,p2);
}
if(l1&&l2) //都可以在左子树中查找到
{
if(root->Left ==p1||root->Left ==p2)
cout<<"他们父级是:"<<root->Left ->value <<endl;
else
Find(root->Left ,p1,p2);
}
if(root->Right )
{
r1=Judge(root->Right ,p1);
r2=Judge(root->Right ,p2);
}
if(r1&&r2) //都可以在左子树中查找到
{
if(root->Right ==p1||root->Right ==p2)
cout<<"他们父级是:"<<root->Right ->value <<endl;
else
Find(root->Right ,p1,p2);
}
if((l1&&r2)||(r1&&l2))
cout<<"他们父级是:"<<root->value <<endl;
}
二叉树的构建代码如下：
void Add(PNode &root,int x)
{
PNode p=new Node;
p->value=x;
p->Left =NULL;
p->Right =NULL;
//cout<<p->value <<endl;
if(!root)
{
root=p;
if(x==6)
q1=p;
if(x==9)
q2=p;
//cout<<temp<<"插入成功！"<<endl;
}
else if(x>root->value )
Add(root->Right ,x);
else
Add(root->Left,x );
}
void Creat(PNode &root) //创建2叉树
{
int temp;
cout<<"输入字符:"<<endl;
cin>>temp;
while(temp) //输入为0 停止
{
Add(root,temp);
cout<<"输入字符:"<<endl;
cin>>temp;
}
}
输入： 5，8，4，3，7，9，6
设定p1指向6， p2指向9；
输出结果如下，正确！！
情况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)步之后，齐头并进，就能解决了。
int getLength (bstNode* pNode)
{
int length = 0;
bstNode* pTemp = pNode;
while (pTemp)
{
length ++ ;
pTemp = pTemp->pParent;
}
return length;
}
bstNode* findLCACase2(bstNode* pNode1, bstNode* pNode2)
{
int length1 = getLength(pNode1);
int length2 = getLength(pNode2);
// skip the abs(length1-length2)
bstNode* pIter1 = NULL;
bstNode* pIter2 = NULL;
int k=0;
if (length1>=length2)
{
bstNode* pTemp = pNode1;
while (k++<length1-length2)
{
pTemp = pTemp->pParent;
}
pIter1 = pTemp;
pIter2 = pNode2;
}
else
{
bstNode* pTemp = pNode2;
while (k++<length2-length1)
{
pTemp = pTemp->pParent;
}
pIter1 = pNode1;
pIter2 = pTemp;
}
while (pIter1&&pIter2&&pIter1!= pIter2)
{
pIter1 = pIter1->pParent;
pIter2 = pIter2->pParent;
}
return pIter1;
}
自己写了个代码，总觉得有些拖沓冗余，希望有缘人看到文章之后能帮我改写的更和谐一些。
还是原来这个图，情况三，如果是个二叉搜索树，而且root和a, b已知，我们这个case假设a,b=3,8。从知道根这个条件我们很自然联想到递归(当然不递归也可以)地往下找。关键是收敛条件，什么情况下可以判断出当然检查的这个节点是最近父亲节点呢？其实从这个例子已经可以看出一些端倪了，如果当前访问的节点比a,b来的都小，肯定不行。如果比a,b都大，也不行。那也就是说，这个节点只有在a<=node<=b的区间内才成立(我们假定a<b这里)。这样的问题，网上广为流传着类似的代码：
bstNode* findLCACase3(bstNode* pNode, int value1, int value2)
{
bstNode* pTemp = pNode;
while (pTemp)
{
if (pTemp->data>value1 && pTemp->data>value2)
pTemp = pTemp->pLeft;
else if(pTemp->data<value1 && pTemp->data<value2)
pTemp = pTemp->pRight;
else
return pTemp;
}
return NULL;
}
好，前面的问题都解决了，我们再回过头来看第一个情况，只有ROOT和left, right节点，没有parent也不是排序树，怎么办？网络上也流传着很多所谓的LCA,RMQ算法，我们不暇找个最合适的，尤其是在面试的时候，特定时间空间下你很难写出一个逻辑非常复杂的东西(比如你会在面试的时候去实现一个Suffix Tree还是用动态规划来求最长公共子串，哪怕效率不同，我也选择动态规划:))。所以这里，碰到类似的问题的时候，我选择简单的记录找到node1和node2的路径，然后再把它们的路径用类似的情况二来做分析，比如还是node1=3,node2=8这个case.我们肯定可以从根节点开始找到3这个节点，同时记录下路径3,4,6,10，类似的我们也可以找到8,6,10。我们把这样的信息存储到两个vector里面，把长的vector开始的多余节点3扔掉，从相同剩余长度开始比较，4!=8,
6==6, coooool,我们找到了我们的答案。下面的代码完全按照这个思路写成
#include <vector>
bool nodePath (bstNode* pRoot, int value, std::vector<bstNode*>& path)
{
if (pRoot==NULL) return false;
if (pRoot->data!=value)
{
if (nodePath(pRoot->pLeft,value,path))
{
path.push_back(pRoot);
return true;
}
else
{
if (nodePath(pRoot->pRight,value,path))
{
path.push_back(pRoot);
return true;
}
else
return false;
}
}
else
{
path.push_back(pRoot);
return true;
}
}
bstNode* findLCACase1(bstNode* pNode, int value1, int value2)
{
std::vector<bstNode*> path1;
std::vector<bstNode*> path2;
bool find = false;
find |= nodePath(pNode, value1, path1);
find &= nodePath(pNode, value2, path2);
bstNode* pReturn=NULL;
if (find)
{
int minSize = path1.size()>path2.size()?path2.size():path1.size();
int it1 = path1.size()-minSize;
int it2 = path2.size()-minSize;
for (;it1<path1.size(),it2<path2.size();it1++,it2++)
{
if (path1[it1]==path2[it2])
{
pReturn = path1[it1];
break;
}
}
}
return pReturn;
}
参考二：
二叉树的节点定义为如下：
typedef struct Node{
int value;
struct Node *Left;
struct Node *Right;
}*PNode;
分析：若节点q1,q2均在root的左子树中，则其最低父节点必定也在做左子树，若均在root的右子树中，同理其父节点在右子树中。若分别存在于root的左右子树中，则当前节点root就是q1,q2的最近父节点。
首先设置一个函数来判断节点q是否包含在root的子树中。根据二叉树的性质可得到如下函数：
bool Judge(PNode p1,PNode p2) //判断p2是否包含在p1的子树中包括p1
{
if(!p1||!p2)
return false;
if(p1->value ==p2->value )
return true;
bool temp=false;
if(p2->value <p1->value ) //小于根节点值，则去左子树寻找
temp=Judge(p1->Left ,p2);
else
temp=Judge(p1->Right ,p2);
return temp;
}
由上述分析以及判断函数可以得到如下代码：
void Find(PNode root,PNode p1,PNode p2) //在以root为根的二叉树中寻找p1,p2节点的最近父节点
{
bool l1,l2,r1,r2;
l1=false;
l2=false;
r1=false;
r2=false;
if(root->Left )
{
l1=Judge(root->Left ,p1);
l2=Judge(root->Left ,p2);
}
if(l1&&l2) //都可以在左子树中查找到
{
if(root->Left ==p1||root->Left ==p2)
cout<<"他们父级是:"<<root->Left ->value <<endl;
else
Find(root->Left ,p1,p2);
}
if(root->Right )
{
r1=Judge(root->Right ,p1);
r2=Judge(root->Right ,p2);
}
if(r1&&r2) //都可以在左子树中查找到
{
if(root->Right ==p1||root->Right ==p2)
cout<<"他们父级是:"<<root->Right ->value <<endl;
else
Find(root->Right ,p1,p2);
}
if((l1&&r2)||(r1&&l2))
cout<<"他们父级是:"<<root->value <<endl;
}
二叉树的构建代码如下：
void Add(PNode &root,int x)
{
PNode p=new Node;
p->value=x;
p->Left =NULL;
p->Right =NULL;
//cout<<p->value <<endl;
if(!root)
{
root=p;
if(x==6)
q1=p;
if(x==9)
q2=p;
//cout<<temp<<"插入成功！"<<endl;
}
else if(x>root->value )
Add(root->Right ,x);
else
Add(root->Left,x );
}
void Creat(PNode &root) //创建2叉树
{
int temp;
cout<<"输入字符:"<<endl;
cin>>temp;
while(temp) //输入为0 停止
{
Add(root,temp);
cout<<"输入字符:"<<endl;
cin>>temp;
}
}
输入： 5，8，4，3，7，9，6
设定p1指向6， p2指向9；
输出结果如下，正确！！
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 寻找二叉树中两个子节点的最近父节点
- [转] 寻找二叉树中两个节点的最近的公共祖先
- 二叉树问题——寻找二叉树中两个节点的最近公共祖先
- 寻找二叉树两节点的最近的公共祖先
- 微软亚洲工程院面试题：寻找两个二叉树节点的最近祖先
- 二叉树中两个子节点的最近公共节点
- 寻找二叉树中两个节点的最近的公共祖先——迅雷笔试归来
- 寻找二叉树两个节点的最近公共祖先
- 寻找二叉树中两个节点的最近的公共祖先
- 寻找二叉树中两个节点的最近的公共祖先
- 寻找二叉树中两个节点的最近祖先
- 二叉树，给定任意两个节点，寻找最近的父节点
- [置顶] 寻找二叉树两节点的最近的公共祖先[转载+整理]
- 利用栈结构实现二叉树的非递归遍历，求二叉树深度、叶子节点数、两个结点的最近公共祖先及二叉树结点的最大距离
- 二叉树中两节点最近公共父节点
- 《程序员面试金典》--寻找二叉树中某个节点中序遍历的下一个节点
- 寻找二叉树两个节点的最低公共祖先
- 求二叉树中两个节点的最近公共祖先节点
- 找出二叉树上任意两个节点的最近共同父节点
- 【BST】在搜索二叉树中，寻找节点数据域在[L,U]范围内的节点