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

题目描述

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

• 其左子树中所有结点的键值小于该结点的键值；
• 其右子树中所有结点的键值大于等于该结点的键值；
• 其左右子树都是二叉搜索树。
• 所谓二叉搜索树的“镜像”，即将所有结点的左右子树对换位置后所得到的树。

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

输入格式：

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

输出格式：

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

输入样例 1：

7
8 6 5 7 10 8 11

输出样例 1：

YES
5 7 6 8 11 10 8

前序判BST+前中生成后序

首先这道题有两道前驱题
18. 重建二叉树
46. 二叉搜索树的后序遍历序列
做完这两题，再来写这道，就会写出这个80行的代码
代码虽复杂，但复用性极高。里面有些写法值得保留

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

const int N = 1010;
int n;
vector<int> pre;
vector<int> in;// 树的中序
int post[N], top;
bool isMirror;

// 根据前序序列判断是否为二叉搜索树
bool isSearch(int l, int r) {
    if (l >= r) return true;
    
    int root = pre[l];
    int k = l + 1;
    while (k <= r && pre[k] < root) k++;
    for (int i = k; i <= r; i++)
        if (pre[i] < root) return false;
    
    return isSearch(l+1, k-1) && isSearch(k, r);
}

// 根据前序序列判断是否为二叉镜向搜索树
bool isSearch2(int l, int r) {
    if (l >= r) return true;
    
    int root = pre[l];
    int k = l + 1;
    while (k <= r && pre[k] >= root) k++;
    for (int i = k; i <= r; i++)
        if (pre[i] > root) return false;
    
    return isSearch2(l+1, k-1) && isSearch2(k, r);
}

void build(int pl, int pr, int il, int ir) {
    if (pl > pr || il > ir) 
        return;

    int k = il;
    if (!isMirror) while(k <= ir && in[k] < pre[pl]) k++;
    else {
        while(k <= ir && in[k] >= pre[pl]) k++;
        k--;
    }
    k -= il; // 左子树的大小
    build(pl + 1, pl + k, il, il + k-1);
    build(pl + k + 1, pr, il + k + 1, ir);
    
    post[top] = pre[pl];
    top++;
}

bool cmp(int a, int b) {
    return a > b;
}

int main() {
    cin >> n;
    
    for (int i = 0; i < n; i++) {
        int x;
        cin >> x;
        pre.push_back(x);
    }
    
    
    if (isSearch(0, pre.size()-1) || isSearch2(0, pre.size()-1)) {
        puts("YES");
        
        in = pre; 
        if (isSearch(0, pre.size()-1)) {
            sort(in.begin(), in.end());
            isMirror = false;
        }
        else {
            sort(in.begin(), in.end(), cmp);
            isMirror = true;
        }
        build(0, n-1, 0, n-1);
        printf("%d", post[0]);
        for (int i = 1; i < n; i++) printf(" %d", post[i]);
        cout << endl;
        
    } else puts("NO");
    
    return 0;
}

感谢朋友tw帮我debug，原来有好几处边界没处理好，只有15分，非常感谢！！！

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

BST性质前序直接转后序

#include <iostream>
#include <vector>

using namespace std;
vector<int> pre, post;
int n;
bool isMirror;

void getpost(int l, int r) {
    if (l > r) return;
    int i = l + 1, j = r;
    
    int root = pre[l];
    if (!isMirror) {
        while (i <= r && pre[i] < root) i++;
        while (j > l && pre[j] >= root) j--;
    } else {
        while (i <= r && pre[i] >= root) i++;
        while (j > l && pre[j] < root) j--;
    }
    if (i - j != 1) return;
    getpost(l + 1, j);
    getpost(i, r);
    
    post.push_back(pre[l]);
}

int main () {
    cin >> n;
    
    for (int i = 0; i < n; i++) {
        int x;
        cin >> x;
        pre.push_back(x);
    }
    
    // 假设是二叉搜索树
    getpost(0, pre.size()-1);
    
    // 二叉搜索树条件不满足，假设是镜向树
    if (post.size() < n) {
        isMirror = true;
        post.clear();
        getpost(0, pre.size()-1);
    } 
    
    if (post.size() == n) {
        puts("YES");
        cout << post[0];
        for (int i = 1; i < post.size(); i++) printf(" %d", post[i]);
    } else puts("NO");
    
    return 0;
}