OJ：GPLT 二叉树小结

本文链接：https://blog.csdn.net/WinterShiver/article/details/123598474

L2-006-树的遍历

给定一棵二叉树的后序遍历和中序遍历，请你输出其层序遍历的序列。这里假设键值都是互不相等的正整数。

输入格式：

输入第一行给出一个正整数N（≤30），是二叉树中结点的个数。第二行给出其后序遍历序列。第三行给出其中序遍历序列。数字间以空格分隔。

输出格式：

在一行中输出该树的层序遍历的序列。数字间以1个空格分隔，行首尾不得有多余空格。

输入样例：

7
2 3 1 5 7 6 4
1 2 3 4 5 6 7

输出样例：

4 1 6 3 5 7 2

解题思路

类似L2-004递归着写
一开始不小心写成了前序遍历。前中后序遍历都是按子树往下分，而层序遍历属于BFS，注意这一层区别

代码

一开始写成前序遍历的代码

#include <iostream>
#include <string>
#include <cstring>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>
#include <cmath>
#include <cstdio>
#include <bitset>
using namespace std;

int n;
int* in;
int* post;
vector<int> result;

void resolve(int p1, int p2, int i1, int i2){
    // 写成前序遍历了
    if(p1 == p2) return;
    int head = post[p2-1];
    result.push_back(head);
    if(p1 == p2-1) return;
    // head in inOrder
    int index = i1;
    while(index<i2){
        if(in[index] == head) break;
        else index++;
    }
    resolve(p1, p1+index-i1, i1, index);
    resolve(p1+index-i1, p2-1, index+1, i2);
}

int main(){
    int n;
    cin >> n;
    in = new int[n];
    post = new int[n];
    for(int i=0; i<n; i++) cin >> post[i];
    for(int i=0; i<n; i++) cin >> in[i];
    resolve(0, n, 0, n);
    for(int i=0; i<n; i++) cout << result[i] << " ";
    return 0;
}

按照BFS的思路，写的层序遍历思路如下（另外也稍微优化了一下代码）：

#include <iostream>
#include <string>
#include <cstring>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>
#include <cmath>
#include <cstdio>
#include <bitset>
using namespace std;

int n;
int* in;
int* post;

struct In{
    int p1;
    int p2;
    int i1; 
    int i2;
};

queue<int> out_seq;
queue<In> indexes;

int resolve(){
    // get operands: head, index(es)
    int head = out_seq.front();
    out_seq.pop();
    int p1 = indexes.front().p1, p2 = indexes.front().p2;
    int i1 = indexes.front().i1, i2 = indexes.front().i2;
    indexes.pop();
    // head in inOrder
    int index = i1;
    while(index<i2){
        if(in[index] == head) break;
        else index++;
    }
    // expand sons first, BFS
    if(p1 < p1+index-i1){ // left not empty
        out_seq.push(post[p1+index-i1-1]);
        indexes.push({p1, p1+index-i1, i1, index});
    }
    if(p1+index-i1 < p2-1){ // right not empty
        out_seq.push(post[p2-2]);
        indexes.push({p1+index-i1, p2-1, index+1, i2});
    }
    return head;
}

int main(){
    int n;
    cin >> n;
    in = new int[n];
    post = new int[n];
    for(int i=0; i<n; i++) cin >> post[i];
    for(int i=0; i<n; i++) cin >> in[i];
    out_seq.push(post[n-1]);
    indexes.push({0, n, 0, n});
    bool flag = true;
    while(!out_seq.empty()){
        int output = resolve();
        if(flag) flag = false;
        else printf(" ");
        printf("%d", output);
    }
    return 0;
}

L2-011 玩转二叉树 (25 分)

给定一棵二叉树的中序遍历和前序遍历，请你先将树做个镜面反转，再输出反转后的层序遍历的序列。所谓镜面反转，是指将所有非叶结点的左右孩子对换。这里假设键值都是互不相等的正整数。

输入格式：

输入第一行给出一个正整数N（≤30），是二叉树中结点的个数。第二行给出其中序遍历序列。第三行给出其前序遍历序列。数字间以空格分隔。

输出格式：

在一行中输出该树反转后的层序遍历的序列。数字间以1个空格分隔，行首尾不得有多余空格。

输入样例：

7
1 2 3 4 5 6 7
4 1 3 2 6 5 7

输出样例：

4 6 1 7 5 3 2

解题思路：

这道题跟上一道几乎是完全的思路：通过两个序列的解析得到树的结构。然后输出。
镜像输出：看似很难，但是考虑到题目里面给出了递归定义，就可以在输出的时候通过“先右后左”很容易地表现出来。

代码：

跟上一道题几乎完全一样。注意有什么修改。

#include <iostream>
#include <string>
#include <cstring>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>
#include <cmath>
#include <cstdio>
#include <bitset>
using namespace std;

int n;
int* in;
int* pre;

struct In{
    int p1;
    int p2;
    int i1; 
    int i2;
};

// 每一个head对应的In都是由这个head领头的树，对应的那一段数组

queue<int> out_seq;
queue<In> indexes;

int resolve(){
    // get operands: head, index(es)
    int head = out_seq.front();
    out_seq.pop();
    int p1 = indexes.front().p1, p2 = indexes.front().p2;
    int i1 = indexes.front().i1, i2 = indexes.front().i2;
    indexes.pop();
    // head in inOrder
    int index = i1;
    while(index<i2){
        if(in[index] == head) break;
        else index++;
    }
    // expand sons first, BFS
    // 镜像：既然镜像的定义是递归地要求先右后左，所以在这里体现出来就可以了
    if(p1+index-i1 < p2-1){ // right not empty
        out_seq.push(pre[p1+index-i1+1]);
        indexes.push({p1+index-i1+1, p2, index+1, i2});
    }
    if(p1 < p1+index-i1){ // left not empty
        out_seq.push(pre[p1+1]);
        indexes.push({p1+1, p1+index-i1+1, i1, index});
    }
    return head;
}

int main(){
    int n;
    cin >> n;
    in = new int[n];
    pre = new int[n];
    for(int i=0; i<n; i++) cin >> in[i];
    for(int i=0; i<n; i++) cin >> pre[i];
    out_seq.push(pre[0]);
    indexes.push({0, n, 0, n});
    bool flag = true;
    while(!out_seq.empty()){
        int output = resolve();
        if(flag) flag = false;
        else printf(" ");
        printf("%d", output);
    }
    return 0;
}

L2-004-二叉搜索树

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

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

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

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

输入格式：

输入的第一行给出正整数 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

解题思路

既然说是递归，肯定写个递归更方便，没啥好讲的
变量定义在外部，方便访问，adjust原地调整也用递归，写的很精妙

代码

#include <iostream>
#include <string>
#include <cstring>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>
#include <cmath>
#include <cstdio>
#include <bitset>
using namespace std;

const int MY_INT_MAX = 0x3f3f3f3f;

static int value[1003];

bool isLeftSmallTree(int begin, int end){
    if(end - begin <= 1) return true;
    int head = value[begin];
    int right_begin = end;
    for(int i=begin+1; i<end; i++){
        if(value[i] >= head)
            right_begin = i;
        if(i >= right_begin && value[i] < head) 
            return false;
    }
    return isLeftSmallTree(begin+1, right_begin) && isLeftSmallTree(right_begin, end);
}

void smallAdjust(int begin, int end){
    if(end - begin <= 1) return;
    int head = value[begin];
    int right_begin = end;
    for(int i=begin+1; i<end; i++){
        if(value[i] >= head){
            right_begin = i;
            break;
        }
    }
    for(int i=begin+1; i<end; i++)
        value[i-1] = value[i];
    value[end-1] = head;
    // 注意顺序往前调了一个
    smallAdjust(begin, right_begin-1);
    smallAdjust(right_begin-1, end-1);
}

bool isLeftBigTree(int begin, int end){
    if(end - begin <= 1) return true;
    int head = value[begin];
    int right_begin = end;
    for(int i=begin+1; i<end; i++){
        if(value[i] < head)
            right_begin = i;
        if(i >= right_begin && value[i] >= head) 
            return false;
    }
    return isLeftBigTree(begin+1, right_begin) && isLeftBigTree(right_begin, end);
}

void bigAdjust(int begin, int end){
    if(end - begin <= 1) return;
    int head = value[begin];
    int right_begin = end;
    for(int i=begin+1; i<end; i++){
        if(value[i] < head){
            right_begin = i;
            break;
        }
    }
    for(int i=begin+1; i<end; i++)
        value[i-1] = value[i];
    value[end-1] = head;
    // 注意顺序往前调了一个
    bigAdjust(begin, right_begin-1);
    bigAdjust(right_begin-1, end-1);
}


int main(){
    int n;
    cin >> n;
    for(int i=0; i<n; i++) cin >> value[i];
    value[n] = -1; // avoid overflow
    if(isLeftSmallTree(0, n)){
        cout << "YES" << endl;
        smallAdjust(0, n);
        cout << value[0];
        for(int i=1; i<n; i++) cout << " " << value[i];
    } 
    else if(isLeftBigTree(0, n)){
        cout << "YES" << endl;
        bigAdjust(0, n);
        cout << value[0];
        for(int i=1; i<n; i++) cout << " " << value[i];
    }
    else cout << "NO";
    return 0;
}