CYK的博客

welcome

0%

L2-004 这是二叉搜索树吗

Posted on

题目

L2-004 这是二叉搜索树吗？ (25 分)

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

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

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

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

输入格式：

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

输出格式：

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

输入样例 1：

1
2
7
8 6 5 7 10 8 11

输出样例 1：

1
2
YES
5 7 6 8 11 10 8

输入样例 2：

1
2
7
8 10 11 8 6 7 5

输出样例 2：

1
2
YES
11 8 10 7 5 6 8

输入样例 3：

1
2
7
8 6 8 5 10 9 11

输出样例 3：

1
NO

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
#include <iostream>
#include <vector>
#include <stdio.h>

using namespace std;

struct TreeNode
{
    TreeNode* left;
    TreeNode* right;
    int val;
};

bool check(vector<bool> ls){
    int count = ls.size();
    int cnt = 0;
    for (int i = 1; i < count; i++)
    {
        if (ls[i-1] != ls[i]) cnt++;
        if (cnt > 1) return false;
    }
    return true;
}

bool build(vector<int> f_ord, TreeNode* root, bool left_smaller){
    int size = f_ord.size();
    root->val = f_ord[0];
    if (size == 1)
    {
        root->left = nullptr;
        root->right = nullptr;
        return true;
    }    
    TreeNode* l = new TreeNode();
    TreeNode* r = new TreeNode();
    vector<int> l_f_ord,r_f_ord;
    vector<bool> to_left(size, false);
    for (int i = 1; i < f_ord.size(); i++)
    {
        if ((f_ord[i] < root->val) == left_smaller)
        {
            r_f_ord.push_back(f_ord[i]);  // 左子树    
            to_left[i] = true;   
        }
        else
        {
            l_f_ord.push_back(f_ord[i]); // 右子树        
            to_left[i] = false;
        }
    }
    //检查是否合法，to_left应该形如1 1 1 0 0 0 或者 0 0 0 1 1 1
    if (!check(to_left)) return false; 
    if (!l_f_ord.empty())
    {
        bool b = build(l_f_ord, l, left_smaller);
        if (!b) return false;
    }
    else l = nullptr;
    if (!r_f_ord.empty())
    {
        bool b = build(r_f_ord, r, left_smaller);
        if (!b) return false;
    }
    else r = nullptr;
    root->left = l;
    root->right = r;
    return true;
}

void visit(TreeNode* root){
    // 后序遍历
    if (root->left) visit(root->left);
    if (root->right) visit(root->right);
    cout << root->val << ' ';
}

int main()  
{
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout); 
    
    int n;
    cin >> n;

    vector<int> first_ord(n, 0);
    for (int i = 0; i < n; i++)
    {
        cin >> first_ord[i];
    }

    TreeNode* root = new TreeNode();
    bool lsmall = n > 1? first_ord[0] < first_ord[1]: true;
    if (build(first_ord, root, lsmall)) 
    {
        cout << "YES" << endl;
        if (root->left) visit(root->left);
        if (root->right) visit(root->right);
        cout << root->val;
    }
    else cout << "NO";

    return 0;
}