L2-004 这是二叉搜索树吗？

这一题真的让我回忆起了很多关于树这一数据结构的代码写法

1.题目描述

一棵二叉搜索树可被递归地定义为具有下列性质的二叉树：对于任一结点，

• 其左子树中所有结点的键值小于该结点的键值；
• 其右子树中所有结点的键值大于等于该结点的键值；
• 其左右子树都是二叉搜索树。

所谓二叉搜索树的“镜像”，即将所有结点的左右子树对换位置后所得到的树。

给定一个整数键值序列，现请你编写程序，判断这是否是对一棵二叉搜索树或其镜像进行前序遍历的结果。

输入格式：

输入的第一行给出正整数 N（≤1000）。随后一行给出 N 个整数键值，其间以空格分隔。

输出格式：

如果输入序列是对一棵二叉搜索树或其镜像进行前序遍历的结果，则首先在一行中输出 YES ，然后在下一行输出该树后序遍历的结果。数字间有 1 个空格，一行的首尾不得有多余空格。若答案是否，则输出 NO。

输入样例 1：

7
8 6 5 7 10 8 11

输出样例 1：

YES
5 7 6 8 11 10 8

输入样例 2：

7
8 10 11 8 6 7 5

输出样例 2：

YES
11 8 10 7 5 6 8

输入样例 3：

7
8 6 8 5 10 9 11

输出样例 3：

NO

2.解题思路

审题后发现输入是树的前序遍历序列。其特点是先遍历根节点，再遍历左子树，最后遍历右子树。

然后题目需要我们将输入与二叉搜索树比较。而二叉搜索树的特点为：左子树的值必须小于此节点值，右节点值大于此节点值。不过刚开始觉得很奇怪，BST按理来说不应该有相等的节点，但是请注意...题目给出了相应条件：右子树大于等于此节点的值。

所以第一步就是要构造一个二叉搜索树，方法直接套BST的插入节点模板即可，节点的每个值已经给出，所以构造出的BST应是唯一的。

那第二步就是拿二叉树和原输入比较了，不过题目还整一出镜像二叉树，问题也不大，把左子树和右子树互换位置即可其他同理。

第三步就是根据比较结果做出相应判断：

3.1 输入序列与二叉搜索树的前序遍历相同,输出“YES”，把搜索二叉树BST的后序遍历打印出来即可。

3.2 输入序列与镜像二叉搜索树的前序遍历相同，输出“YES”，将搜索二叉树的左右子树交换，然后后续遍历即可。

3.3 输入序列与其都不相同，那么就不能构成一个二叉搜索树，输出“NO”.

这题还很恶心，最后一个输出的值不能带有空格否则说格式错误，解决方法就是先把结果存到一个容器(vector)里，后续拿出来就好，如果是最后一个就打印回车即可

每步对应的函数：

第一步构造BST二叉搜索树：

void prebuild(BiTree &root,int key)；

第二步与输入比较：

（镜像）前序遍历：void preTraverse(BiTree T)；

比较: bool check(int s[],int s1[])；

第三步多种情况判断：

对应main函数的if语句；

后续遍历：void postTraverse(BiTree T)；

3.参考代码

#include <iostream>
#include <malloc.h>
#include <vector>
using namespace std;

const int MAX=1005;

typedef struct BiTNode
{
    int data;
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

int N;
int s[MAX],pre1[MAX],pre2[MAX];
int index=0;
vector<int> ans;
BiTree T=NULL;

void prebuild(BiTree &root,int key)
{
    if(root==NULL){
        root=(BiTree)malloc(sizeof(BiTNode));
        root->data=key;
        root->lchild=root->rchild=NULL;
    }
    else if(key<root->data){
        prebuild(root->lchild,key);
    }
    else{
        prebuild(root->rchild,key);
    }
}

void preTraverse(BiTree T)
{
    if(T==NULL) return;
    pre1[index++]=T->data;
    preTraverse(T->lchild);
    preTraverse(T->rchild);
}

void preTraverse_mirror(BiTree T)
{
    if(T==NULL) return;
    pre2[index++]=T->data;
    preTraverse_mirror(T->rchild);
    preTraverse_mirror(T->lchild);
}

bool check(int s[],int s1[])
{
    for(int i=0;i<N;i++){
        if(s[i]==s1[i]) continue;
        else return false;
    }
    return true;
}

void postTraverse(BiTree T)
{
    if(T==NULL) return;;
    postTraverse(T->lchild);
    postTraverse(T->rchild);
    ans.push_back(T->data);
}

void postTraverse_mirror(BiTree T)
{
    if(T==NULL) return;;
    postTraverse_mirror(T->rchild);
    postTraverse_mirror(T->lchild);
    ans.push_back(T->data);
}

int main()
{
    cin>>N;
    for(int i=0;i<N;i++) cin>>s[i];
    for(int i=0;i<N;i++){
        prebuild(T,s[i]);
    }

    preTraverse(T);
    index=0;
    preTraverse_mirror(T);
    if(check(s,pre1)){
        cout<<"YES"<<endl;
        postTraverse(T);
        for(int i=0;i<N;i++){
            printf("%d%c",ans[i],i==N-1?'\n':' ');
        }
    }
    else if(check(s,pre2)){
        cout<<"YES"<<endl;
        postTraverse_mirror(T);
        for(int i=0;i<N;i++){
            printf("%d%c",ans[i],i==N-1?'\n':' ');
        }
    }
    else{
        cout<<"NO"<<endl;
    }
    return 0;
}

关注后续更新~~