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

判断一棵二叉树是否为搜索树和完全二叉树，解题思路：
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;
}

测试结果：