C++根据前中序重建二叉树，并输出后序遍历

给定一个二叉树的前序遍历和中序遍历的序列，输出对应这个二叉树的后续遍历序列。

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
#include <string>
using namespace std;

//Definition for binary tree
template <typename T>
struct TreeNode {
    T val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(T x) : val(x), left(NULL), right(NULL) { }
};

template <typename T>
class Solution {
public:
    TreeNode<T>* reConstructBinaryTree(vector<T> pre, vector<T> vin) {
        int len = pre.size();
        if (len == 0)
            return NULL;

        //创建根节点，并初始化
        TreeNode<T>* root = new TreeNode<T>(pre[0]);
        int mid = 0;

        //得到根节点在中序遍历的下标
        for (int i = 0; i < len; i++)
        {
            if (vin[i] == pre[0])
            {
                mid = i;
                break;
            }
        }

        //储存左子树
        vector<T> pre_left, vin_left, pre_right, vin_right;
        for (int i = 0; i < mid; i++)
        {
            pre_left.push_back(pre[i + 1]);
            vin_left.push_back(vin[i]);
        }

        //储存右子树
        for (int i = mid + 1; i < len; i++)
        {
            pre_right.push_back(pre[i]);
            vin_right.push_back(vin[i]);
        }

        //递归重建
        root->left = reConstructBinaryTree(pre_left, vin_left);
        root->right = reConstructBinaryTree(pre_right, vin_right);

        return root;
    }
    
    //后序遍历
    void pastOrder(TreeNode<T>* p)
    {
        if (p == NULL)
        {
            return;
        }

        pastOrder(p->left);
        pastOrder(p->right);
        cout << p->val;
    }
};

int main()
{
    vector<int> pre, vin;
    int a[] = { 1,2,4,7,3,5,6,8 };
    int b[] = { 4,7,2,1,5,3,8,6 };

    int len = sizeof(a) / sizeof(a[0]);
    for (int i = 0; i < len; i++)
    {
        pre.push_back(a[i]);
        vin.push_back(b[i]);
    }

    Solution<int> s;
    s.reConstructBinaryTree(pre, vin);

    vector<char> vec_s1, vec_s2;
    string s1, s2;
    cin >> s1 >> s2;

    s1 = s1.c_str();
    s2 = s2.c_str();
    int len_s = s1.length();

    for (int i = 0; i < len_s; i++)
    {
        vec_s1.push_back(s1[i]);
        vec_s2.push_back(s2[i]);
    }

    Solution<char> str_s;
    TreeNode<char>* root = str_s.reConstructBinaryTree(vec_s1, vec_s2);

    str_s.pastOrder(root);

	return 0;
}