PAT 1020 Tree Traversals

#include <iostream>
#include <map>
#include <vector>
/**
 * 给定一棵树的后序和中序遍历,给出其对应的层序遍历
 */
using namespace std;
int postorder[35];
int inorder[35];
map<int,vector<int>> map1;
struct TreeNode{
    TreeNode* left;
    TreeNode* right;
    int val;
};
TreeNode* constructTree(int beg1,int end1,int beg2,int end2){
    if(beg1>end1){
        return nullptr;
    }
    int index;
    int val=postorder[end2];
    for ( index = beg1; index <=end1 ; ++index) {
        if (inorder[index]==val){
            break;
        }
    }
    auto* node=new TreeNode();
    node->val=val;
    node->left=constructTree(beg1,index-1,beg2,index-1-beg1+beg2);
    node->right=constructTree(index+1,end1,index-beg1+beg2,end2-1);
    return node;
}
void dfs(TreeNode* node,int dep){
    if(node== nullptr){
        return;
    }
    map1[dep].push_back(node->val);
    dfs(node->left,dep+1);
    dfs(node->right,dep+1);
}
int main() {
    int N;
    cin>>N;
    for (int i = 0; i < N; ++i) {
        cin>>postorder[i];
    }
    for (int j = 0; j < N; ++j) {
        cin>>inorder[j];
    }
    TreeNode* root=constructTree(0,N-1,0,N-1);
    dfs(root,0);
    bool first= true;
    for(const auto& pair:map1){
        auto vec=pair.second;
        for (auto a:vec){
            if(first){
                cout<<a;
                first=false;
            } else{
                cout<<" "<<a;
            }
        }
    }
    return 0;
}

当然还有非常传统的利用队列进行层序遍历的方法,并且这种方法效率较高.

#include <iostream>
#include <queue>
using namespace std;
struct TreeNode{
    int val;
    TreeNode* left;
    TreeNode* right;
};
int inorder[32];
int postorder[32];

TreeNode* constructTree(int beg1,int end1,int beg2,int end2){
    if(beg1>end1){
        return nullptr;
    }
    int val=postorder[end2];
    auto* node=new TreeNode();
    node->val=val;
    int index=beg1;
    for (int i = beg1; i <= end1; ++i) {
        if(inorder[i]==val){
            index=i;
            break;
        }
    }
    node->left=constructTree(beg1,index-1,beg2,index-1-beg1+beg2);
    node->right=constructTree(index+1,end1,index-beg1+beg2,end2-1);
    return node;
}

void levelOrder(TreeNode* root){
    queue<TreeNode*> queue1;
    bool first=true;
    queue1.push(root);
    while (!queue1.empty()){
        auto node=queue1.front();
        queue1.pop();
        if (first){
            cout<<node->val;
            first=false;
        } else{
            cout<<" "<<node->val;
        }
        if(node->left!= nullptr){
            queue1.push(node->left);
        }
        if(node->right!= nullptr){
            queue1.push(node->right);
        }
    }

}
int main() {
    int N;
    cin>>N;
    for (int i = 0; i < N; ++i) {
        cin>>postorder[i];
    }
    for (int j = 0; j < N; ++j) {
        cin>>inorder[j];
    }
    TreeNode* root=constructTree(0,N-1,0,N-1);
    levelOrder(root);
    return 0;
}