判断一棵二叉树是否是平衡二叉树并求一颗二叉树的镜像——题集十

判断一棵二叉树是否是平衡二叉树并求一颗二叉树的镜像——题集十

        今天分享一下判断一棵二叉树是否是平衡二叉树并求一棵二叉树的镜像，并且判断在递增矩阵中某数是否存在。

        判断一棵二叉树是否是平衡二叉树/求一棵二叉树的镜像的源代码和运行示例。

源代码如下：

#include<iostream>
using namespace std;
 
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x)
:val(x)
,left(NULL)
,right(NULL)
{
    }
};
 
bool _IsBalanceTree(TreeNode* root, int&  height,int& HD){//Height difference->HD高度差
if(root == NULL){
height=0;
HD=0;
return true;
}
//HD>0，左边高；HD<0,右边高。
int left= 0;
int leftHD= 0;
if(_IsBalanceTree( root->left, left, leftHD)){
//if(abs(leftHD)>1) return false;//左子树的
int right= 0;
int rightHD=0;
if(_IsBalanceTree( root->right, right, rightHD)){
//if(abs(rightHD)>1) return false;//右子树的高度差的绝对值不能大于1
if(abs(left-right)>0 && (abs(leftHD)+abs(rightHD))>1) return false;//左右子树的高度有差值，且左右子树高度差绝对值的和大于1
if(abs(HD)>1) return false;
if(left>right){
height=left+1;
HD = left-right;//计算差值
if(abs(HD)>1) return false;//高度差的绝对值不能大于1
return true;
}
else{
height=right+1;
HD = left-right;//计算差值
if(abs(HD)>1) return false;//高度差的绝对值不能大于1
return true;
}
}
return false;
}
return false;
}
 
//判断一棵二叉树是否是平衡二叉树
bool IsBalanceTree(TreeNode* root){//左右两个子树的高度差的绝对值不超过1->后序
int height=0;
int HD=0;
return _IsBalanceTree( root, height, HD);
}
 
void _Mirror(TreeNode* root){
if(root==NULL) return;
 
_Mirror(root->left);
_Mirror(root->right);
 
swap(root->left, root->right);
}
 
void PrintTree(TreeNode* root){//先序
if(root==NULL) return;
 
cout<<root->val<<" ";
 
PrintTree(root->left);
PrintTree(root->right);
}
 
//求一颗二叉树的镜像
TreeNode* Mirror(TreeNode* root){//求一颗二叉树的镜像->//后序遍历
TreeNode* tmp=root;
if(tmp==NULL)return tmp;
 
_Mirror(tmp);
 
return tmp;
}
 
void Test(TreeNode * pRoot1){//测试用例
cout<<"先序遍历： ";
PrintTree(pRoot1);//先序
 
cout<<"判断一棵二叉树是否是平衡二叉树: "<<IsBalanceTree(pRoot1)<<endl;//左右两个子树的高度差的绝对值不超过1->后序
 
cout<<"求一颗二叉树的镜像"<<endl;
TreeNode* tmp = Mirror(pRoot1);//求一颗二叉树的镜像->//后序遍历
cout<<"Mirror(pRoot1)->先序遍历： ";
PrintTree(tmp);//先序
tmp = Mirror(pRoot1);//为方便接下来的测试，复原原函数
}
 
void TestTree24(){//判断一棵二叉树是否是平衡二叉树+求一颗二叉树的镜像
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;
cout<<"**********************************************"<<endl<<endl;
 
pRoot1->left = pRoot2;
pRoot2->left = pRoot4;
Test(pRoot1);//测试用例
cout<<endl<<endl;
 
pRoot4->left = pRoot8;  //
Test(pRoot1);//测试用例 //测试用例二屏蔽这三行即可。
cout<<endl<<endl;       //
 
pRoot1->right = pRoot3;
pRoot3->right = pRoot7;
Test(pRoot1);//测试用例
cout<<endl<<endl;
 
pRoot2->right = pRoot5;
Test(pRoot1);//测试用例
cout<<endl<<endl;
 
pRoot3->left = pRoot6;
Test(pRoot1);//测试用例
cout<<endl<<endl;
 
pRoot7->right = pRoot9;
Test(pRoot1);//测试用例
cout<<endl<<endl;
 
cout<<"**********************************************"<<endl;
}
 
int main(){
TestTree24();//判断一棵二叉树是否是平衡二叉树+求一颗二叉树的镜像
system("pause");
return 0;
}

运行结果：

测试用例一

 

测试用例二

       一个m*n的矩阵，从左到右从上到下都是递增的，给一个数x，判断x是否在矩阵中。要求效率尽可能的高。

其源代码和运行示例如下所示。

源代码如下：

#include<iostream>
using namespace std;
 
//一个m*n的矩阵，从左到右从上到下都是递增的，给一个数x，判断x是否在矩阵中。要求效率尽可能的高。
bool FindIsExit(int target, vector<vector<int> > array){
int rows= array.size();//
int cols=array[0].size();
 
if(rows<=0 || cols<=0)return false;
 
if(array[0][0]>target || array[rows-1][cols-1]<target)return false;
 
//左下角
int left_rows=rows-1;
int left_cols=0;
 
while(left_rows>=0 && left_cols<cols){
if(array[left_rows][left_cols]>target){//大于目标值上移
left_rows--;
}
else if(array[left_rows][left_cols]<target){//小于目标值右移
left_cols++;
}
else{
return true;
}
}
 
return false;
}
 
void TestExit(){//判断x是否在矩阵中
vector<vector<int>> array;
int ary[3][4]={
1,2,4,6
,3,6,9,12
,4,8,12,16
};
 
cout<<"打印矩阵"<<endl;
for(int i=0; i<3; i++){
vector<int> tmp;
for(int j=0; j<4; j++){
tmp.push_back(ary[i][j]);
cout<<ary[i][j]<<" ";
}
cout<<endl;
array.push_back(tmp);
}
cout<<endl;
 
cout<<"FindIsExit(3, array)"<<FindIsExit(3, array)<<endl;
cout<<"FindIsExit(5, array)"<<FindIsExit(5, array)<<endl;
cout<<"FindIsExit(8, array)"<<FindIsExit(8, array)<<endl;
cout<<"FindIsExit(16, array)"<<FindIsExit(16, array)<<endl;
 
}
 
int main(){
cout<<"判断x是否在从左到右从上到下都是递增的矩阵中"<<endl<<endl;
TestExit();//判断x是否在矩阵中
system("pause");
return 0;
}

运行结果：

 

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