判断一棵树是否是完全二叉树和求二叉树中两个节点的最近公共祖先——题集（十三）

判断一棵树是否是完全二叉树和求二叉树中两个节点的最近公共祖先——题集（十三）
       今天来分享一下，如何判断一棵树是否是完全二叉树和求二叉树中两个节点的最近公共祖先的代码实现和运行示例。

      首先分享判断一棵树是否是完全二叉树的源代码和运行示例。

       提示：层序遍历变型题。

源代码如下：

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

struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int x)
:val(x)
,left(NULL)
,right(NULL)
{
}
};

//判断一棵树是否是完全二叉树
bool IsCompleteBT(TreeNode* root){
//递归层序遍历——队列
//同一层前面结点没有孩子节点，后面也不可能有,设置标志位
if(root==NULL) return true;//默认空树是完全二叉树
bool flag=true;
queue<TreeNode*> tmp;
tmp.push(root);
TreeNode* cur=NULL;

while(!tmp.empty()){
cur=tmp.front();
tmp.pop();

if(cur->left != NULL){
if(flag)
tmp.push(cur->left);
else
return false;
}
else
flag=false;

if(cur->right != NULL){
if(flag)
tmp.push(cur->right);
else
return false;
}
else
flag=false;
}
return true;
}

void TestTree(){////判断一棵树是否是完全二叉树
TreeNode * pRoot1=new TreeNode(1);
TreeNode * pRoot2=new TreeNode(2);
TreeNode * pRoot3=new TreeNode(3);
TreeNode * pRoot4=new TreeNode(4);
TreeNode * pRoot5=new TreeNode(5);
TreeNode * pRoot6=new TreeNode(6);
TreeNode * pRoot7=new TreeNode(7);
TreeNode * pRoot8=new TreeNode(8);
TreeNode * pRoot9=new TreeNode(9);

cout<<"判断一棵树是否是完全二叉树"<<endl<<endl;
pRoot1->right = pRoot3;
cout<<"IsCompleteBT(pRoot1): "<<IsCompleteBT(pRoot1)<<endl;//判断一棵树是否是完全二叉树

pRoot1->left = pRoot2;
cout<<"IsCompleteBT(pRoot1): "<<IsCompleteBT(pRoot1)<<endl;

pRoot3->left = pRoot6;
pRoot3->right = pRoot7;
cout<<"IsCompleteBT(pRoot1): "<<IsCompleteBT(pRoot1)<<endl;

pRoot2->left = pRoot4;
pRoot2->right = pRoot5;
cout<<"IsCompleteBT(pRoot1): "<<IsCompleteBT(pRoot1)<<endl;
}

int main(){
TestTree();////判断一棵树是否是完全二叉树

system("pause");
return 0;
}
运行结果：

 


       求二叉树中两个节点的最近公共祖先的源代码和运行示例。 

       要求考虑以下三种种情况，给出解决方案，并解决：

1：二叉树的每个节点有parent（三叉链）

源代码如下：

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

//求二叉树中两个节点的最近公共祖先
//1：二叉树每个节点有parent（三叉链）
struct TreeNodeT {
int _val;
struct TreeNodeT * _parent;
struct TreeNodeT * _left;
struct TreeNodeT * _right;
TreeNodeT(int x) :
_val(x), _left(NULL), _right(NULL),_parent(NULL){
}
};

TreeNodeT* LeastCommonAN1(TreeNodeT* p1,TreeNodeT* p2){//求二叉树中两个节点的最近公共祖先——二叉树每个节点有parent
if(p1==NULL) return p2;
if(p2==NULL) return p1;
if(p1->_val == p2->_val) return p1;
stack<TreeNodeT*> tmp1;
stack<TreeNodeT*> tmp2;
TreeNodeT* cur1=p1;
TreeNodeT* cur2=p2;

while(cur1->_parent != NULL){
if(cur1->_parent->_val == p2->_val) return p2;
cur1=cur1->_parent;
tmp1.push(cur1);
}

while(cur2->_parent != NULL){
if(cur2->_parent->_val == p1->_val) return p1;
cur2=cur2->_parent;
tmp2.push(cur2);
}
TreeNodeT* root=NULL;
while(!tmp1.empty() && !tmp2.empty()){
if(tmp1.top()->_val == tmp2.top()->_val){
root=tmp1.top();
}
else{
return root;
}

tmp1.pop();
tmp2.pop();
}

return NULL;
}

void TestT1(){//求二叉树中两个节点的最近公共祖先——二叉树每个节点有parent
TreeNodeT * pRoot1=new TreeNodeT(1);
TreeNodeT * pRoot2=new TreeNodeT(2);
TreeNodeT * pRoot3=new TreeNodeT(3);
TreeNodeT * pRoot4=new TreeNodeT(4);
TreeNodeT * pRoot5=new TreeNodeT(5);
TreeNodeT * pRoot6=new TreeNodeT(6);
TreeNodeT * pRoot7=new TreeNodeT(7);
TreeNodeT * pRoot8=new TreeNodeT(8);
TreeNodeT * pRoot9=new TreeNodeT(9);

pRoot1->_left = pRoot2;
pRoot2->_parent = pRoot1;

pRoot1->_right = pRoot3;
pRoot3->_parent = pRoot1;

pRoot2->_left = pRoot4;
pRoot4->_parent = pRoot2;

pRoot2->_right = pRoot5;
pRoot5->_parent = pRoot2;

pRoot3->_left = pRoot6;
pRoot6->_parent = pRoot3;

pRoot3->_right = pRoot7;
pRoot7->_parent = pRoot3;

pRoot4->_left = pRoot8;
pRoot8->_parent = pRoot4;

cout<<"求二叉树中两个节点的最近公共祖先——二叉树每个节点parent"<<endl<<endl;

TreeNodeT* root= LeastCommonAN1(pRoot8,pRoot3);
if(root!=NULL)
cout<<"LeastCommonAN1(pRoot8,pRoot3)： "<<root->_val<<endl;
else
cout<<"LeastCommonAN1(pRoot8,pRoot3)： 不存在"<<endl;
cout<<endl;

root= LeastCommonAN1(pRoot4,pRoot6);
if(root!=NULL)
cout<<"LeastCommonAN1(pRoot4,pRoot6)： "<<root->_val<<endl;
else
cout<<"LeastCommonAN1(pRoot4,pRoot6)： 不存在"<<endl;
cout<<endl;

root= LeastCommonAN1(pRoot2,pRoot6);
if(root!=NULL)
cout<<"LeastCommonAN1(pRoot2,pRoot6)： "<<root->_val<<endl;
else
cout<<"LeastCommonAN1(pRoot2,pRoot6)： 不存在"<<endl;
cout<<endl;

root= LeastCommonAN1(pRoot8,pRoot2);
if(root!=NULL)
cout<<"LeastCommonAN1(pRoot8,pRoot2)： "<<root->_val<<endl;
else

4000
cout<<"LeastCommonAN1(pRoot8,pRoot2)： 不存在"<<endl;
cout<<endl;

root= LeastCommonAN1(pRoot8,pRoot9);
if(root!=NULL)
cout<<"LeastCommonAN1(pRoot8,pRoot9)： "<<root->_val<<endl;
else
cout<<"LeastCommonAN1(pRoot8,pRoot9)： 不存在"<<endl;
cout<<endl;

root= LeastCommonAN1(pRoot1,pRoot9);
if(root!=NULL)
cout<<"LeastCommonAN1(pRoot1,pRoot9)： "<<root->_val<<endl;
else
cout<<"LeastCommonAN1(pRoot1,pRoot9)： 不存在"<<endl;
cout<<endl;
}

int main(){
TestT1();//求二叉树中两个节点的最近公共祖先——二叉树每个节点有parent

system("pause");
return 0;
}
运行结果：


 
2：二叉树是搜索二叉树。

源代码如下：

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

struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int x)
:val(x)
,left(NULL)
,right(NULL)
{
}
};

//2：二叉树是搜索二叉树。 它或者是一棵空树，或者是具有下列性质的二叉树：
//若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
//若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
//它的左、右子树也分别为二叉排序树。
//中序遍历有序
bool IsAncent(TreeNode* p1,TreeNode* p2){//判断p1是否是p2的祖先结点
if(p1==NULL|| p2==NULL) return false;
if(p1->val == p2->val) return true;
else if(p1->val > p2->val){
return IsAncent(p1->left,p2);
}
else{
return IsAncent(p1->right,p2);
}
}

void _Find2(queue<TreeNode*>& tmp, TreeNode* root,TreeNode* p){//得到从根到P结点的路径
while(root!=NULL){
if(root->val == p->val){
break;
}
else if(root->val > p->val){
tmp.push(root);
root = root->left;
}
else{
tmp.push(root);
root = root->right;
}
}
}

TreeNode* LeastCommonAN2(TreeNode* root,TreeNode* p1,TreeNode* p2){//求二叉树中两个节点的最近公共祖先——二叉树是搜索二叉树
if(root==NULL) return root;
if(p1==NULL) return p2;
if(p2==NULL) return p1;
if(IsAncent(p1,p2)) return p1;//判断p1是否是p2的祖先结点
if(IsAncent(p2,p1)) return p2;//判断p2是否是p1的祖先结点

queue<TreeNode*> tmp1;
TreeNode* cur=root;
_Find2( tmp1, cur, p1);//得到从根到P1结点的路径
if(cur==NULL) return NULL;//p1不在该树中

queue<TreeNode*> tmp2;
cur=root;
_Find2( tmp2, cur, p2);//得到从根到P2结点的路径
if(cur==NULL) return NULL;//p2不在该树中

TreeNode* aim=NULL;

while(!tmp1.empty() && !tmp2.empty()){
if(tmp1.front()->val == tmp2.front()->val){
aim=tmp1.front();
}
else{
return aim;
}

tmp1.pop();
tmp2.pop();
}

return aim;
}

void TestT2(){//求二叉树中两个节点的最近公共祖先——二叉树是搜索二叉树
TreeNode * root0=new TreeNode(8);
TreeNode * root1=new TreeNode(5);
TreeNode * root2=new TreeNode(14);
TreeNode * root3=new TreeNode(2);
TreeNode * root4=new TreeNode(6);
TreeNode * root5=new TreeNode(18);

root0->left = root1;
root0->right = root2;
root1->left = root3;
root1->right = root4;
root2->right = root5;

cout<<"求二叉树中两个节点的最近公共祖先——二叉树是搜索二叉树"<<endl<<endl;
TreeNode* root= LeastCommonAN2(root0,root4, root3);
if(root!=NULL)
cout<<"LeastCommonAN2(root0,root4, root3)： "<<root->val<<endl;
else
cout<<"LeastCommonAN2(root0,root4, root3)： 不存在"<<endl;
cout<<endl;

root= LeastCommonAN2(root0,root4,root5);
if(root!=NULL)
cout<<"LeastCommonAN2(root0,root4, root5)： "<<root->val<<endl;
else
cout<<"LeastCommonAN2(root0,root4, root5)： 不存在"<<endl;
cout<<endl;

root= LeastCommonAN2(root0,root2,root5);
if(root!=NULL)
cout<<"LeastCommonAN2(root0,root2, root5)： "<<root->val<<endl;
else
cout<<"LeastCommonAN2(root0,root2, root5)： 不存在"<<endl;
cout<<endl;
}

int main(){
TestT2();//求二叉树中两个节点的最近公共祖先——二叉树是搜索二叉树

system("pause");
return 0;
}
运行结果：


 
3：就是普通二叉树。（尽可能实现时间复杂度为O（N））

源代码如下：

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

struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int x)
:val(x)
,left(NULL)
,right(NULL)
{
}
};

//3：就是普通二叉树。
void _Find3(stack<TreeNode*>& tmp, TreeNode* root,TreeNode* p){//得到从根到P1结点的路径
TreeNode* cur=root;
TreeNode* prev=NULL;
while(cur!=NULL || !tmp.empty()){//后序
while(cur && cur != prev){
tmp.push(cur);
if(cur->val == p->val){
return ;
}
cur=cur->left;
}

if(tmp.top()->right == prev || tmp.top()->right == NULL)
{
prev = tmp.top();
tmp.pop();
}
if(!tmp.empty())
cur=tmp.top()->right;
else
break;
}
return ;
}

//把以p1和p2的路径求出来找相同即可，不分是否以p1和p2为公共结点
TreeNode* LeastCommonAN3(TreeNode* root,TreeNode* p1,TreeNode* p2){
if(root==NULL) return root;
TreeNode* cur=root;

stack<TreeNode*> tmp1;
_Find3(tmp1, cur,p1);//得到从根到P1结点的路径

stack<TreeNode*> tmp2;
cur=root;
_Find3(tmp2, cur,p2);//得到从根到P1结点的路径

TreeNode* aim=NULL;

while(!tmp1.empty() && !tmp2.empty()){
while(tmp1.size()!= tmp2.size()){
if(tmp1.size()> tmp2.size())
tmp1.pop();
else
tmp2.pop();
}
//找到第一个相似结点
if(tmp1.top()->val == tmp2.top()->val){
aim=tmp1.top();
return aim;
}

tmp1.pop();
tmp2.pop();
}

return aim;
}

void TestTree3(){//求二叉树中两个节点的最近公共祖先——二叉树是普通二叉树
TreeNode * pRoot1=new TreeNode(1);
TreeNode * pRoot2=new TreeNode(2);
TreeNode * pRoot3=new TreeNode(3);
TreeNode * pRoot4=new TreeNode(4);
TreeNode * pRoot5=new TreeNode(5);
TreeNode * pRoot7=new TreeNode(7);
TreeNode * pRoot8=new TreeNode(8);
TreeNode * pRoot9=new TreeNode(9);

pRoot1->left = pRoot2;
pRoot1->right = pRoot3;
pRoot2->left = pRoot4;
pRoot2->right = pRoot5;
pRoot3->right = pRoot7;
pRoot4->left = pRoot8;

cout<<"求二叉树中两个节点的最近公共祖先——普通二叉树"<<endl<<endl;
TreeNode* root= LeastCommonAN3(pRoot1,pRoot8,pRoot3);
if(root!=NULL)
cout<<"LeastCommonAN3(pRoot1,pRoot8,pRoot3)： "<<root->val<<endl;
else
cout<<"LeastCommonAN3(pRoot1,pRoot8,pRoot3)： 不存在"<<endl;
cout<<endl;

root= LeastCommonAN3(pRoot1,pRoot9,pRoot3);
if(root!=NULL)
cout<<"LeastCommonAN3(pRoot1,pRoot9,pRoot3)： "<<root->val<<endl;
else
cout<<"LeastCommonAN3(pRoot1,pRoot9,pRoot3)： 不存在"<<endl;
cout<<endl;

root= LeastCommonAN3(pRoot1,pRoot4,pRoot7);
if(root!=NULL)
cout<<"LeastCommonAN3(pRoot1,pRoot4,pRoot7)： "<<root->val<<endl;
else
cout<<"LeastCommonAN3(pRoot1,pRoot4,pRoot7)： 不存在"<<endl;
cout<<endl;

root=LeastCommonAN3(pRoot1,pRoot8,pRoot5);
if(root!=NULL)
cout<<"LeastCommonAN3(pRoot1,pRoot8,pRoot5)： "<<root->val<<endl;
else
cout<<"LeastCommonAN3(pRoot1,pRoot8,pRoot5)： 不存在"<<endl;
cout<<endl;

root= LeastCommonAN3(pRoot1,pRoot8,pRoot9);
if(root!=NULL)
cout<<"LeastCommonAN3(pRoot1,pRoot8,pRoot9)： "<<root->val<<endl;
else
cout<<"LeastCommonAN3(pRoot1,pRoot8,pRoot9)： 不存在"<<endl;
cout<<endl;

root= LeastCommonAN3(pRoot1,pRoot1,pRoot7);
if(root!=NULL)
cout<<"LeastCommonAN3(pRoot1,pRoot1,pRoot7)： "<<root->val<<endl;
else
cout<<"LeastCommonAN3(pRoot1,pRoot1,pRoot7)： 不存在"<<endl;
cout<<endl;
}

int main(){
TestTree3();//求二叉树中两个节点的最近公共祖先——二叉树是普通二叉树

system("pause");
return 0;
}
运行结果：


 
分享如上，如有错误，望斧正！愿大家学得开心，共同进步！