剑指offer7 重建二叉树

剑指offer7 重建二叉树

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

注意:

    二叉树中每个节点的值都互不相同；
    输入的前序遍历和中序遍历一定合法；

样例

给定：
前序遍历是：[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

思路：

    1、递归构造树，所以第一步要写明确递归终止的条件，即数组中结点为空的时候，返回空。
    2、构造 新的结点，即前序遍历的第一个结点，并且找到其在中序遍历中的位置
    3、构造其左右子树，把前序遍历列表分为左右子树前序列表，把中序遍历分为了左右子树中序列表
    4、返回构造好的结点，递归依次对其进行循环构造。

AcWing-18 C++ code：

/**
    * 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:
       TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
           
           if(preorder.empty() || inorder.empty()){
               return NULL;
           }
           
           TreeNode* head = new TreeNode(preorder[0]);
           
           int head_id = 0;
           for(int i = 0; i < inorder.size(); i++){
               if(head->val == inorder[i]){
                   head_id = i;
                   break;
               }
           }
           
           vector<int> pre_left, pre_right, in_left, in_right;
           for(int i = 0; i < head_id; i++){
               pre_left.push_back(preorder[i+1]);
               in_left.push_back(inorder[i]);
           }
           for(int i = head_id + 1; i < preorder.size(); i++){
               pre_right.push_back(preorder[i]);
               in_right.push_back(inorder[i]);
           }
           
           head->left = buildTree(pre_left, in_left);
           head->right = buildTree(pre_right, in_right);
           
           return head;
       }
   };

牛客网 C++ code:

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
        if(pre.empty() || vin.empty()){
            return NULL;
        }
        TreeNode *head = new TreeNode(pre[0]);
        vector<int> pre_left;
        vector<int> pre_right;
        vector<int> vin_left;
        vector<int> vin_right;
        int head_id = 0;
        for(; vin[head_id] != head->val; head_id++){
            pre_left.push_back(pre[head_id + 1]);
            vin_left.push_back(vin[head_id]);
        }
        for(head_id = head_id + 1; head_id < pre.size(); head_id++){
            pre_right.push_back(pre[head_id]);
            vin_right.push_back(vin[head_id]);
        }
        head->left = reConstructBinaryTree(pre_left, vin_left);
        head->right = reConstructBinaryTree(pre_right, vin_right);
        return head;
    }
};

AcWing-18 python code：

     # 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
             """
             if not preorder or not inorder:
                 return None
             
             head = TreeNode(preorder[0])
             
             head_id = 0
             for i in range(len(inorder)):
                 if inorder[i] == preorder[0]:
                     head_id = i
                     break
             
             pre_left = []
             pre_right = []
             in_left = []
             in_right = []
             for i in range(head_id):
                 pre_left.append(preorder[i + 1])
                 in_left.append(inorder[i])
             for i in range(head_id + 1, len(inorder)):
                 pre_right.append(preorder[i])
                 in_right.append(inorder[i])
                
                
                head.left = self.buildTree(pre_left, in_left)
                head.right = self.buildTree(pre_right, in_right)
                
                return head