输入某二叉树的前序遍历和中序遍历的结果。请重建二叉树，假设输入的前序遍历和中序遍历的结果都不包含重复的数字

输入某二叉树的前序遍历和中序遍历的结果。请重建二叉树，假设输入的前序遍历和中序遍历的结果都不包含重复的数字使用c++解决

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

// 定义二叉树节点结构
struct TreeNode {
    int val; // 节点的值
    TreeNode *left; // 左子树指针
    TreeNode *right; // 右子树指针
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} // 构造函数，初始化节点值，并将左右子树指针设为 nullptr
};

class Solution {
public:
    // 主函数，用于根据前序和中序遍历构建二叉树
    TreeNode* buildTree(std::vector<int>& preorder, std::vector<int>& inorder) {
        int preIndex = 0; // 初始化前序遍历索引
        // 调用辅助函数构建二叉树
        return buildTreeHelper(preorder, inorder, preIndex, 0, inorder.size() - 1);
    }

private:
    // 辅助函数，用于递归构建二叉树
    TreeNode* buildTreeHelper(const std::vector<int>& preorder, const std::vector<int>& inorder,
                              int& preIndex, int inStart, int inEnd) {
        if (inStart > inEnd) return nullptr; // 如果中序遍历的起始索引大于结束索引，返回 nullptr

        int rootValue = preorder[preIndex++]; // 获取当前子树的根节点值，并更新前序遍历索引
        TreeNode* root = new TreeNode(rootValue); // 创建根节点

        // 在中序遍历中找到根节点的位置
        int inIndex = inStart;
        while (inIndex <= inEnd && inorder[inIndex] != rootValue) {
            ++inIndex; // 遍历中序遍历数组，找到根节点的位置
        }

        // 递归构建左子树
        root->left = buildTreeHelper(preorder, inorder, preIndex, inStart, inIndex - 1);
        // 递归构建右子树
        root->right = buildTreeHelper(preorder, inorder, preIndex, inIndex + 1, inEnd);

        return root; // 返回构建好的树的根节点
    }
};

// 用于测试：中序遍历打印重建的树
void inorderTraversal(TreeNode* root) {
    if (root == nullptr) return; // 如果根节点为空，直接返回
    inorderTraversal(root->left); // 递归遍历左子树
    std::cout << root->val << " "; // 打印当前节点值
    inorderTraversal(root->right); // 递归遍历右子树
}

int main() {
    std::vector<int> preorder = {3, 9, 20, 15, 7}; // 定义前序遍历数组
    std::vector<int> inorder = {9, 3, 15, 20, 7}; // 定义中序遍历数组

    Solution solution; // 创建 Solution 类的实例
    TreeNode* root = solution.buildTree(preorder, inorder); // 构建二叉树

    std::cout << "重建的二叉树的中序遍历结果："; // 输出提示
    inorderTraversal(root); // 中序遍历打印二叉树
    std::cout << std::endl; // 输出换行符

    return 0; // 返回 0 表示程序执行成功
}

上面是递归的方法

下面使用非递归的方法

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

// 定义二叉树节点结构
struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

class Solution {
public:
    TreeNode* buildTree(std::vector<int>& preorder, std::vector<int>& inorder) {
        if (preorder.empty()) return nullptr; // 如果前序遍历为空，直接返回 nullptr

        std::stack<TreeNode*> stk; // 创建一个栈来模拟递归
        TreeNode* root = new TreeNode(preorder[0]); // 创建根节点
        stk.push(root); // 将根节点推入栈中

        int inorderIndex = 0; // 中序遍历的索引

        for (int i = 1; i < preorder.size(); ++i) {
            int preValue = preorder[i];
            TreeNode* node = stk.top(); // 获取栈顶元素

            if (node->val != inorder[inorderIndex]) {
                node->left = new TreeNode(preValue); // 创建左子节点
                stk.push(node->left); // 将左子节点推入栈中
            } else {
                while (!stk.empty() && stk.top()->val == inorder[inorderIndex]) {
                    node = stk.top();
                    stk.pop();
                    ++inorderIndex;
                }
                node->right = new TreeNode(preValue); // 创建右子节点
                stk.push(node->right); // 将右子节点推入栈中
            }
        }

        return root; // 返回根节点
    }
};

// 用于测试：中序遍历打印重建的树
void inorderTraversal(TreeNode* root) {
    if (root == nullptr) return;
    inorderTraversal(root->left);
    std::cout << root->val << " ";
    inorderTraversal(root->right);
}

int main() {
    std::vector<int> preorder = {3, 9, 20, 15, 7}; // 定义前序遍历数组
    std::vector<int> inorder = {9, 3, 15, 20, 7}; // 定义中序遍历数组

    Solution solution; // 创建 Solution 类的实例
    TreeNode* root = solution.buildTree(preorder, inorder); // 构建二叉树

    std::cout << "重建的二叉树的中序遍历结果："; // 输出提示
    inorderTraversal(root); // 中序遍历打印二叉树
    std::cout << std::endl; // 输出换行符

    return 0; // 返回 0 表示程序执行成功
}