判断一棵二叉树是否为搜索二叉树和完全二叉树（第一版，运行超时,第二版，运行通过！！！）

判断一棵二叉树是否为搜索树和完全二叉树，解题思路：
1.首先根据输入建立树结构。
2.中序遍历，判断序列是否单调增，如果符合，则为搜索树。
3.判断树是否为完全树，即：不存在只有右孩子没有左孩子的节点，且只有左孩子没有右孩子的节点至多只有一个。

代码实现思路：
1.构造树的时候，树的节点采用结构体Node。根据输入依次插入节点，插入过程为：递归查找目标节点，插入其左右子节点。
2.中序遍历，采用递归的形式得到一个数组，判断数组中相邻值的大小关系。
3.采用队列进行树的层次遍历，将左右孩子都非空的节点加入队列，如果遇到只有右孩子没有左孩子的节点则直接返回false,如果遇到只有左孩子没有右孩子的节点，则继续判断之后的节点全是叶子节点。

运行结果：
该思路对于简单的例子可以运行成功，但在牛客网测试发现数据量过大时，存在超时现象。

优化思路：
构造树的过程中采用哈希表，减少构造树的过程中查找节点插入子节点的时间。在后续的学习中，将进行进一步的优化。

源代码：

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <queue>
using namespace std;
struct Node{
Node *lchild;
Node *rchild;
int c;
}Tree[500001];
int loc;
Node *creat(){
Tree[loc].lchild=Tree[loc].rchild=NULL;
return &Tree[loc++];
}
int arr[500001];
int size;

void inOrder(Node *T){
if(T->lchild!=NULL){
inOrder(T->lchild);
}
arr[size++]=T->c;
if(T->rchild!=NULL){
inOrder(T->rchild);
}
}

Node *findNode(Node *T,int x,bool &flag){
Node *ret;
if(T==NULL) return T;
if(T->c==x)
{
flag=true;
ret=T;
}
else{
if(T->lchild!=NULL){
ret=findNode(T->lchild,x,flag);
}
if(!flag&&T->rchild!=NULL){
ret=findNode(T->rchild,x,flag);
}
}
return ret;
}
void insert(int root,int left,int right){
bool flag=false;
Node *T=findNode(&Tree[0],root,flag);
if(left!=0){
Node* leftNode=creat();
leftNode->c=left;
T->lchild=leftNode;
}
if(right!=0){
Node* rightNode=creat();
rightNode->c=right;
T->rchild=rightNode;
}
}

queue<Node*> Q;
bool check(Node *T){
while(Q.empty()==false) Q.pop();
if(T==NULL) return false;
Q.push(T);
while(Q.empty()==false){
Node* T=Q.front();
Q.pop();
if(T->lchild!=NULL&&T->rchild!=NULL){
Q.push(T->lchild);
Q.push(T->rchild);
}
else if(T->lchild==NULL&&T->rchild!=NULL){
return false;
}
else {
if(T->lchild!=NULL)Q.push(T->lchild);
while(Q.empty()==false){
Node* P=Q.front();
Q.pop();
if(P->lchild!=NULL||P->rchild!=NULL)return false;
}
}
}
return true;
}
int main(){
int n;
int root;
scanf("%d%d",&n,&root);
loc=0;
Node *T=creat();
T->c=root;
int ro,left,right;
n--;
while(n!=0){
scanf("%d%d%d",&ro,&left,&right);
insert(ro,left,right);
if(left!=0) n--;
if(right!=0) n--;
}
inOrder(T);
bool flag=true;
for(int i=0;i<size-1;i++){
if(arr[i]>arr[i+1])flag=false;
}
puts(flag? "true":"false");
bool completeFlag=check(T);
puts(completeFlag? "true":"false");
return 0;
}

感谢您的观看，写博客一是为了交流，二是为了记录解题的思路。
希望我的博客能对你有所帮助！

一天后，我又来更新了！！！！

第二版

优化思路：
构建树的时候采用哈希表。
根据题意我用一个Tree[500001]来存储树的节点，索引代表着该节点的值，数组内部存储Node结构体，记录该节点的子节点。这样查找树中节点的复杂度为O(1)。
在修改的过程中，其余方法也进行了相应的修正。

源代码：

#include <stdio.h>
#include <string.h>
#include <queue>
using namespace std;
struct Node{
int lchild;
int rchild;
}Tree[500001];
void creat(int root){
Tree[root].lchild=Tree[root].rchild=-1;
}
int arr[500001];
int size;
void inOrder(int T){
if(Tree[T].lchild>0){
inOrder(Tree[T].lchild);
}
arr[size++]=T;
if(Tree[T].rchild>0){
inOrder(Tree[T].rchild);
}
}

void insert(int root,int left,int right){
creat(root);
if(left!=0){
Tree[root].lchild=left;
}
if(right!=0){
Tree[root].rchild=right;
}
}

queue<Node> Q;
bool check(int root){
while(Q.empty()==false) Q.pop();
if(root<=0) return false;
Q.push(Tree[root]);
while(Q.empty()==false){
Node T=Q.front();
Q.pop();
if(T.lchild>0&&T.rchild>0){
Q.push(Tree[T.lchild]);
Q.push(Tree[T.rchild]);
}
else if(T.lchild<=0&&T.rchild>0)return false;
else{
if(T.lchild>0)Q.push(Tree[T.lchild]);
while(Q.empty()==false){
Node P=Q.front();
Q.pop();
if(P.lchild>0||P.rchild>0)return false;
}
}
}
return true;
}

int main(){
int n;
int root;
scanf("%d%d",&n,&root);
creat(root);
n--;
int ro,left,right;
while(n!=0){
scanf("%d%d%d",&ro,&left,&right);
insert(ro,left,right);
if(left!=0) n--;
if(right!=0) n--;
}
inOrder(root);
bool flag=true;
for(int i=0;i<size-1;i++){
if(arr[i]>arr[i+1])flag=false;
}
puts(flag? "true":"false");
bool completeFlag=check(root);
puts(completeFlag? "true":"false");
return 0;
}

测试结果：

• 点赞
• 收藏
• 分享
• 文章举报