题目

输入一棵二叉树前序遍历和中序遍历的结果，请重建该二叉树。

注意:

二叉树中每个节点的值都互不相同；输入的前序遍历和中序遍历一定合法；数据范围树中节点数量范围 [0,100][0,100]。

样例给定：前序遍历是：[3, 9, 20, 15, 7] 中序遍历是：[9, 3, 15, 20, 7]

返回：[3, 9, 20, null, null, 15, 7, null, null, null, null] 返回的二叉树如下所示：
3
/ \
9 20
/ \
15 7

解析

递归建立整棵二叉树，先递归创建左右子树，然后创建根节点，并让指针指向两个子树

先根据前序遍历找根节点：前序遍历第一个数就是根结点的值；
在中序遍历中找到根结点的位置k，k左边就是左子树中序遍历，k右边就是右子树中序遍历；
左子树中序遍历长度是k - il，所以前序遍历第一个数pl后的k-il个数就是左子树前序遍历，剩下来的就是右子树前序遍历；
有了左右子树的前序遍历和中序遍历，就可以递归创建左右子树然后再创建根结点。

代码

C++

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> preorder, inorder;
    unordered_map<int, int> hash;
    
    TreeNode* buildTree(vector<int>& _preorder, vector<int>& _inorder) {
        preorder = _preorder, inorder = _inorder;
        
        for (int i = 0; i < inorder.size(); i ++ ) {
            hash[inorder[i]] = i;
        }
        return dfs(0, preorder.size() - 1, 0, inorder.size() - 1);
    }
    
    TreeNode* dfs(int pl, int pr, int il, int ir) {
        if (pl > pr) 
            return nullptr;
        auto root = new TreeNode(preorder[pl]);
        int k = hash[root->val];
        auto left =  dfs(pl + 1, pl + k - il, il, k - 1);
        auto right = dfs(pl + k + 1 - il, pr, k + 1, ir);
        root->left = left, root->right = right;
        
        return root;
    }
};

Python

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution(object):
    def buildTree(self, preorder, inorder):
        """
        :type preorder: List[int]
        :type inorder: List[int]
        :rtype: TreeNode
        """
        hash = {}
        for i, x in enumerate(inorder):
            hash[x] = i
        
        def dfs(pl, pr, il, ir):
            if pl > pr:
                return None
            root = TreeNode(preorder[pl])
            k = hash[preorder[pl]]
            left = dfs(pl + 1, pl + k - il, il, k - 1)
            right = dfs(pl + k - il + 1, pr, k + 1, ir)
            root.left = left
            root.right = right
        
            return root
        return dfs(0, len(preorder) - 1, 0, len(inorder) - 1)

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func buildTree(preorder []int, inorder []int) *TreeNode {
    hash := make(map[int]int)
    for idx, v := range inorder {
        hash[v] = idx
    }
    
    var dfs func(int, int, int, int) *TreeNode
    dfs = func(pl, pr, il, ir int) *TreeNode {
        if pl > pr {
            return nil
        }
        
        root := &TreeNode {Val: preorder[pl]}
        
        k := hash[preorder[pl]]
        
        left := dfs(pl + 1, pl + k - il, il, k - 1)
        right := dfs(pl + k -il + 1, pr, k + 1, ir);
        
        root.Left = left
        root.Right = right
        
        return root
    }
    
    return dfs(0, len(preorder) - 1, 0, len(inorder) - 1)
}

剑指Offer-重建二叉树

题目

解析

代码