基础实验4-2.4 搜索树判断 (25分)

最新推荐文章于 2025-06-23 09:49:57 发布

原创最新推荐文章于 2025-06-23 09:49:57 发布 · 1.1k 阅读

2 ·

CC 4.0 BY-SA版权

数据结构专栏收录该内容

37 篇文章

订阅专栏

本文介绍了一种算法，用于判断给定的整数序列是否为二叉搜索树或其镜像树的前序遍历，并输出对应的后序遍历序列。通过构建二叉树并比较前序遍历结果，实现了对输入序列的有效验证。

基础实验4-2.4 搜索树判断 (25分)
对于二叉搜索树，我们规定任一结点的左子树仅包含严格小于该结点的键值，而其右子树包含大于或等于该结点的键值。如果我们交换每个节点的左子树和右子树，得到的树叫做镜像二叉搜索树。

现在我们给出一个整数键值序列，请编写程序判断该序列是否为某棵二叉搜索树或某镜像二叉搜索树的前序遍历序列，如果是，则输出对应二叉树的后序遍历序列。

输入格式:
输入的第一行包含一个正整数N（≤1000），第二行包含N个整数，为给出的整数键值序列，数字间以空格分隔。

输出格式:
输出的第一行首先给出判断结果，如果输入的序列是某棵二叉搜索树或某镜像二叉搜索树的前序遍历序列，则输出YES，否侧输出NO。如果判断结果是YES，下一行输出对应二叉树的后序遍历序列。数字间以空格分隔，但行尾不能有多余的空格。

输入样例1:
7
8 6 5 7 10 8 11

输出样例1:
YES
5 7 6 8 11 10 8

输入样例2:
7
8 6 8 5 10 9 11

输出样例2:
NO

//用链表的形式
#include<iostream>
using namespace std;
struct BNode{
    int data;
    struct BNode* left;
    struct BNode* right;
};
    
/*这里的tree是一个引用，去掉引用符号，main()中的tree仍然是NULL，没有改变tree的值；
 有引用&，第一次函数传进来时是NULL，后面传出是tree总是指向头结点8，*/

void Insert(struct BNode* &tree,int data){
    static int cnt=0;
    if(!tree){
        struct BNode* p=(struct BNode*)malloc(sizeof(struct BNode));
        p->data=data;
        //cout<<"check001:"<<p->data<<endl;     8 6 5 7 10 8 11
        p->left=NULL;
        p->right=NULL;
        tree=p;         //tree->left=p;or tree->right=p;
        //cout<<"check002:"<<tree->data<<endl;  8 6 5 7 10 8 11
    }
    else if(data<tree->data){/*cout<<"insert left "<<++cnt<<endl;*/Insert(tree->left, data);}
    else if(data>=tree->data){/*cout<<"insert right "<<++cnt<<endl;*/Insert(tree->right, data);}
    //cout<<"check003:"<<tree->data<<endl; 测试用，输出的值总为8
}

int b[100],a[100];;int cnt1=0;int cnt2=0;

void PreorderTraversal(struct BNode* tree){
    if(tree){
        b[cnt1++]=tree->data;
        //cout<<"cnt1++: "<<tree->data<<endl;
        PreorderTraversal(tree->left);
        PreorderTraversal(tree->right);
    }
}

void PostorderTraversal(struct BNode* tree){
    if(tree){
           a[cnt2++]=tree->data;
            cout<<tree->data<<endl;
           PostorderTraversal(tree->right);
           PostorderTraversal(tree->left);
       }
}

void printPostOder(int N){
    cout<<"后序遍历输出:"<<endl;
    for(int i=N-1;i>=0;i--){
        cout<<a[i]<<" ";
    }
    cout<<endl;
}

int main(){
    struct BNode* tree=NULL;
    int N,data,cnt3=0;
    cin>>N;
    int c[N];
    for(int i=0;i<N;i++){
        cin>>data;
        c[i]=data;
        Insert(tree,data);
    }
    PreorderTraversal(tree);
    for(int i=0;i<N;i++){
        if(b[i]==c[i]){
            ++cnt3;
            //cout<<b[cnt3++]<<"  "<<c[i]<<"  "<<endl;
            //cnt3++;       cn3初始化为0，cn3++返回0， 从0-6，
            //++cnt3,       cn3++返回1， 从1-7，
        }
    }
    //cout<<cnt3;
    if(cnt3==N){
        cout<<"Yes"<<endl;
        PostorderTraversal(tree);
        printPostOder(N);
    }else
        cout<<"NO"<<endl;
    return 0;
}

#include <iostream>
#include<vector>
#include<stdio.h>
using namespace std;
struct bst{
    int data;
    bst *left,*right;
};
vector<int>v1,v2,v3,v4,v5,v6;
bst *init(int key){
    bst *tmp=new bst;
    tmp->data=key;
    tmp->left=tmp->right=NULL;
    return tmp;
}
bst *insert(bst *root,int key){
    if(root==NULL){
        return init(key);
    }else if(key>=root->data){
        root->right=insert(root->right,key);
    }else if(key<root->data){
        root->left=insert(root->left,key);
    }
    return root;
}
void PreTranse(bst *root){
    if(root==NULL){
        return ;
    }else{
        v5.push_back(root->data);
        //printf("%d ",root->data);
        PreTranse(root->left);
        PreTranse(root->right);
    }
}

void InorderTranse(bst *root){
    if(root==NULL){
        return ;
    }else{
        InorderTranse(root->left);
        v1.push_back(root->data);
        v2.push_back(root->data);
        v4.push_back(root->data);
        //printf("%d ",root->data);
        InorderTranse(root->right);
    }
}

void PostTranse(bst *root){
    if(root==NULL){
        return ;
    }else{
        PostTranse(root->left);
        PostTranse(root->right);
        v6.push_back(root->data);
    }
}
bool cmp(int x,int y){
    return x>=y;
}
int main() {
    int n;
    cin>>n;
    int x;
    bst *root=NULL;
    for(int i=0;i<n;i++){
        cin>>x;
        v3.push_back(x);
        root=insert(root,x);
    }
    InorderTranse(root);
    sort(v2.begin(),v2.end());
    sort(v4.begin(),v4.end(),cmp);
    int flag=0,flag1=0;
    int tag=0;
    for(int i=0;i<v1.size();i++){       //判断是否为单增，否则flag=1;
        if(v1[i]==v2[i]){continue;}
        flag=1;
    }
    for(int i=0;i<v1.size();i++){       //判断是否为单减,否则flag1=1;
        if(v1[i]==v4[i]){continue;}
        flag1=1;
    }
    if(flag==1&&flag1==1){cout<<"NO"<<endl;return 0;}
    PreTranse(root);
    for(int i=0;i<v3.size();i++){
        if(v3[i]==v5[i]){continue;}
        else tag=1;
    }
    if(tag==1){cout<<"NO"<<endl;}
    else{
        cout<<"YES"<<endl;
        PostTranse(root);
        int i=0;
        for(;i<v6.size()-1;i++){
            printf("%d ",v6[i]);
        }
        printf("%d\n",v6[i]);
    }
    return 0;
}