通过二叉树的拓展前序遍历序列读出中序遍历序列，用模板类写出代码

模板类代码如下：

#include <iostream>
#include <vector>
#include <stack>
#include <unordered_map>

template <typename T>
class TreeNode {
public:
    T val;
    TreeNode* left;
    TreeNode* right;

    TreeNode(T v) : val(v), left(nullptr), right(nullptr) {}
};

template <typename T>
class Solution {
public:
    std::vector<T> getInorder(std::vector<T>& preorder, std::vector<T>& extend) {
        int n = preorder.size();
        std::stack<TreeNode<T>*> stk;
        TreeNode<T>* root = new TreeNode<T>(preorder[0]);
        stk.push(root);

        int j = 0;
        for (int i = 1; i < n; ++i) {
            TreeNode<T>* node = new TreeNode<T>(preorder[i]);
            if (extend[i] == 'L') {
                stk.top()->left = node;
            } else {
                while (!stk.empty() && stk.top()->right != nullptr) {
                    stk.pop();
                }
                if (!stk.empty()) {
                    stk.top()->right = node;
                }
            }
            stk.push(node);
        }

        std::vector<T> inorder(n);
        std::unordered_map<TreeNode<T>*, bool> vis;
        stk.push(root);
        while (!stk.empty()) {
            TreeNode<T>* node = stk.top();
            if (node->left && !vis[node->left]) {
                stk.push(node->left);
            } else {
                inorder[j++] = node->val;
                vis[node] = true;
                stk.pop();
                if (node->right && !vis[node->right]) {
                    stk.push(node->right);
                }
            }
        }

        return inorder;
    }
};

int main() {
    std::vector<int> preorder {1, 2, 4, 5, 3, 6, 7};
    std::vector<char> extend {'N', 'L', 'L', 'N', 'N', 'L', 'N'};
    Solution<int> s;
    std::vector<int> inorder = s.getInorder(preorder, extend);
    for (int i : inorder) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
    return 0;
}

其中，`getInorder`函数接收两个参数，分别是拓展前序遍历序列和拓展序列。首先根据拓展序列构建二叉树，然后进行中序遍历并记录结果。在构建二叉树时，我们可以使用一个栈来记录当前的遍历路径，如果遇到左子树，直接将节点作为父节点的左孩子；如果遇到右子树，需要在栈中找到第一个没有右孩子的父节点，将节点作为其右孩子。在遍历过程中，使用一个哈希表来记录节点是否被访问过，避免重复访问。最后返回中序遍历结果。