（LeetCode C++）从前序与中序遍历序列构造二叉树_preorder c++ 前序遍历 数组模拟

给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。

示例 1:

输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
输出: [3,9,20,null,null,15,7]

示例 2:

输入: preorder = [-1], inorder = [-1]
输出: [-1]

提示:

1 <= preorder.length <= 3000
inorder.length == preorder.length
-3000 <= preorder[i], inorder[i] <= 3000
preorder 和 inorder 均 无重复 元素
inorder 均出现在 preorder
preorder 保证 为二叉树的前序遍历序列
inorder 保证 为二叉树的中序遍历序列

首先，二叉树的实现是：

// Definition for a binary tree node
class TreeNode
{
public:
    int val;
    TreeNode *left;
    TreeNode *right;
 
    TreeNode()
    {
        this->val=0;
        this->left=nullptr;
        this->right=nullptr;
    }
 
    TreeNode(int x)
    {
        this->val=x;
        this->left=nullptr;
        this->right=nullptr;
    }
 
    TreeNode(int x,TreeNode *left,TreeNode *right)
    {
        this->val=x;
        this->left=left;
        this->right=right;
    }
};

Method：

1. 前序遍历的第一个节点，是树的根节点。
2. 在中序遍历中，根节点的左边均是左子树，右边均是右子树。

因此按照以上的规则进行递归即可。

Code 0：

class Solution{
public:
    // 递归构造二叉树
    TreeNode *sub_buildTree(vector<int> &preorder,int start_pre,int end_pre,vector<int> &inorder,int start_in,int end_in){
        // 如果前序遍历开始指针在前序遍历结束指针之后
        if(start_pre>end_pre){
            // 返回null
            // 即为到达了叶节点
            return nullptr;
        }
 
        // 创建一个新节点
        TreeNode *root=new TreeNode(preorder[start_pre]);
 
        // 记录先序遍历的第一个节点再中序遍历数组中的位置
        int root_index=start_in;
        // 遍历中序遍历数组
        for(;root_index<=end_in;root_index++){
            // 寻找根节点的位置
            if(inorder[root_index]==root->val){
                // 找到后即结束遍历
                break;
            }
        }
 
        // 递归遍历左子树
        root->left= sub_buildTree(preorder,start_pre+1,start_pre+root_index-start_in,inorder,start_in,root_index-1);
        // 递归遍历右子树
        root->right= sub_buildTree(preorder,start_pre+root_index-start_in+1,end_pre,inorder,root_index+1,end_in);
 
        // 返回该节点
        return root;
    }
 
    // 从前序与中序遍历序列构造二叉树
    TreeNode *buildTree(vector<int> &preorder,vector<int> &inorder){
        // 记录二叉树的节点个数
        int n=preorder.size();
        // 递归构造二叉树
        return sub_buildTree(preorder,0,n-1,inorder,0,n-1);
    }
};

Code 1：

class Solution{
public:
    unordered_map<int,int> indexMap;
 
    // 递归构造二叉树
    TreeNode *sub_buildTree(vector<int> &preorder,int start_pre,int end_pre,vector<int> &inorder,int start_in,int end_in){
        // 如果前序遍历开始指针在前序遍历结束指针之后
        if(start_pre>end_pre){
            // 返回null
            // 即为到达了叶节点
            return nullptr;
        }
 
        // 创建一个新节点
        TreeNode *root=new TreeNode(preorder[start_pre]);
 
        // 记录先序遍历的第一个节点在中序遍历数组中的位置
        int root_index=indexMap[preorder[start_pre]];
 
        // 递归遍历左子树
        root->left= sub_buildTree(preorder,start_pre+1,start_pre+root_index-start_in,inorder,start_in,root_index-1);
        // 递归遍历右子树
        root->right= sub_buildTree(preorder,start_pre+root_index-start_in+1,end_pre,inorder,root_index+1,end_in);
 
        // 返回该节点
        return root;
    }
 
    // 从前序与中序遍历序列构造二叉树
    TreeNode *buildTree(vector<int> &preorder,vector<int> &inorder){
        // 记录二叉树的节点个数
        int n=preorder.size();
 
        // 利用unordered map记录中序遍历中每一个节点的index
        for(int i=0;i<n;i++){
            indexMap[inorder[i]]=i;
        }
 
        // 递归构造二叉树
        return sub_buildTree(preorder,0,n-1,inorder,0,n-1);
    }
};

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/construct-binary-tree-from-preorder-and-inorder-traversal