二叉树——前序中序后序

1. 概述

• 前序：根节点 > 左节点 > 右节点
• 中序：左节点 > 根节点 > 右节点
• 后序：左节点 > 右节点 > 根节点

2. 根据前序、中序重建二叉树

给出：
前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]

①. 由前序遍历能够得到根节点为3
②. 由中序遍历以及根节点可将inorder划分成 左子树|根节点|右子树 ，即9|3|15,20,7
③. 由左子树、右子树又可将preorder划分成 根节点|左子树|右子树 ，即3|9|20,15,7

然后再对
前序：20,15,7
中序：15,20,7
执行上述①②③，得到根节点20，左子树15，右子树7
得到：

    3
  /    \
 9     20  
      /   \
     15    7

3. 代码实现

利用递归实现

• python3 – 1

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:

        self.reserch = {}
        self.pre = preorder
        for i in range(len(inorder)):
            self.reserch[inorder[i]] = i
        
        res = self.recur(0, 0, len(preorder)-1)
        return res

    def recur(self, pre_root_id, in_left_id, in_right_id):
        if in_left_id > in_right_id:
            return None
        root_node = self.pre[pre_root_id]
        root = TreeNode(root_node)

        in_idx_root_node = self.reserch[root_node]

        root.left = self.recur(pre_root_id + 1, in_left_id, in_idx_root_node - 1)
        root.right = self.recur(in_idx_root_node - in_left_id + pre_root_id + 1, in_idx_root_node+1, in_right_id)

        return root

• python3 – 2

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
        if preorder == []:
            return None
        root_val = preorder[0]
        root = TreeNode(root_val)
        for i in range(len(inorder)):
            if inorder[i] == root_val:
                break
        root.left = self.buildTree(preorder[1:1+i], inorder[:i])
        root.right = self.buildTree(preorder[1+i:], inorder[i+1:])
        return root

• C++

class Solution {
public:
    unordered_map<int, int> get_inorder_idx;
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if (preorder.empty()){
            return nullptr;
        }
        short int length = inorder.size();
        for (short int i=0;i<length;++i)
            get_inorder_idx[inorder[i]] = i;
        
        return recur(preorder, 0, 0, length-1);
    }

    TreeNode* recur(const vector<int>& preorder,short int root_idx, short int left_idx, short int right_idx){

        if (left_idx>right_idx){
            return nullptr;
        }
        int root_node = preorder[root_idx];
        auto root = new TreeNode(root_node);
        short int in_root_idx = get_inorder_idx[root_node];

        root->left = recur(preorder, root_idx+1, left_idx, in_root_idx-1);
        root->right = recur(preorder, in_root_idx+root_idx-left_idx+1, in_root_idx+1, right_idx);

        return root;
    }
};