LeetCode 105. 从前序与中序遍历序列构造二叉树（C++）

1.题目如下：

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

示例 1:

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

示例 2:

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

提示:

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

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/construct-binary-tree-from-preorder-and-inorder-traversal
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2.代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:

//思路：
/*
 *首先 先序遍历：[根][左子树的先序][右子树的先序]  中序遍历：[左子树的中序][根][右子树的中序]
 *只要确定了根在两个数组中的位置，就可以很容易通过递归在两个子树范围内找到所有的根然后链接；
 *对于中序遍历，根左边的范围内的节点一定是左子树的结点，右边的节点就是右子树；
 *根据中序遍历的左右两边的节点数目可以知道在先序遍历中的左右子树的结点范围
 
*/
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        int n=preorder.size();
        return myBuildTree(preorder,inorder,0,n-1,0,n-1);
    }
    TreeNode* myBuildTree(const vector<int>& preorder, const vector<int>& inorder, int preorder_left, int preorder_right, int inorder_left, int inorder_right) {
        //代表上一层的根节点已经没有子结点了
        if(preorder_left>preorder_right){
            return nullptr;
        }
        //前序遍历的第一个结点就是根节点
        int preorder_root=preorder_left;
        //定位根节点在中序遍历数组中的位置
        int inorder_root=index(preorder[preorder_root],inorder);
        //生成树的根节点
        TreeNode *root=new TreeNode(preorder[preorder_root]);
        //在中序遍历数组中根节点位置左边的部分就是左子树
        int size_left_subtree=inorder_root-inorder_left;
        //对左子树部分递归，链接左子树的根节点
        root->left=myBuildTree(preorder,inorder,preorder_left+1,preorder_left+size_left_subtree,inorder_left,inorder_root-1);
        //对右子树部分递归，链接右子树的根节点
        root->right=myBuildTree(preorder,inorder,preorder_left+size_left_subtree+1,preorder_right,inorder_root+1,inorder_right);
        //每一次都返回子树的根供上一层的递归链接
        return root;
    }
    
    int index(int x,const vector<int>& inorder){
        for(int i=0;i<inorder.size();i++){
            if(inorder[i]==x){
                return i;
            }
        }
        return 0;
    }
}；
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56