[Leetcode] 105. Construct Binary Tree from Preorder and Inorder Traversal 解题报告

题目：

Given preorder and inorder traversal of a tree, construct the binary tree.

Note:
You may assume that duplicates do not exist in the tree.

思路：

1、无预处理的递归：在先序序列中的第一个元素为根节点，这个节点在中序序列中会将节点分为左右两个部分，其左边为根节点的左子树的所有节点，而右边为右子树的所有节点。所以我们需要做的就是每次根据先序遍历中的首元素，将先序序列和中序序列都分成两个部分，然后递归实现树的构造。具体请见代码片段1，思路很直观。

2、添加预处理的递归：在代码片段1中我们发现，递归过程中每次都需要花费线性的时间去查找先序序列的首元素在中序序列中位置，这无形中造成了重复计算。一个可行的方法就是我们首先建立一个哈希表（或者直接采用两个数组，并且建立映射数值到位置的索引），预先计算出每个元素在中序序列中的位置，然后在需要查找时直接返回结果就可以。这样的好处是可以将查找这一部分的总体时间复杂度从O(n^2)降低到O(n)。具体实现请见代码片段2。实验表明，采用哈希表之后，程序的运行速度果然有大幅度提升。

代码：

1、无预处理的递归：

/**
 * 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.size() == 0) {
            return NULL;
        }    
        return buildTree(preorder, 0, preorder.size() - 1, inorder, 0, inorder.size() - 1);
    }
private:
    TreeNode* buildTree(vector<int>& preorder, int preLeft, int preRight,
                        vector<int>& inorder, int inLeft, int inRight) {
        if(inLeft > inRight) {
            return NULL;
        }
        else
        {
            TreeNode* root = new TreeNode(preorder[preLeft]);
            int index = -1;
            for(int i = inLeft; i <= inRight; ++i) {
                if(inorder[i] == preorder[preLeft]) {
                    index = i;
                    break;
                }
            }
            int leftTreeSize = index - inLeft;
            int rightTreeSize = inRight - index;
            root->left = buildTree(preorder, preLeft + 1, preLeft + leftTreeSize, inorder, inLeft, index - 1);
            root->right = buildTree(preorder, preLeft + leftTreeSize + 1, preRight, inorder, index + 1, inRight);
            return root;
        }
    }
};

2、添加预处理的递归：

/**
 * 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) {  
        int len = preorder.size();  
        for(int i = 0; i < len; i++) {
            hash[inorder[i]] = i;  
        }
        return rebuild(preorder, 0, len, 0);  
    }
private:  
    TreeNode* rebuild(vector<int>& preorder, int cur_pos, int len, int start) {  
        if(len <= 0) {
            return NULL;
        }
        TreeNode *root = new TreeNode(preorder[cur_pos]);  
        int pos = hash[preorder[cur_pos]];
        int len1 = pos - start;       // the number of nodes in left sub tree
        int len2 = len - len1-1;      // the number of nodes in right sub tree
        root->left = rebuild(preorder, cur_pos + 1, len1, start);  
        root->right = rebuild(preorder, cur_pos + len1 + 1, len2, pos + 1);  
        return root;  
    }
    unordered_map<int, int> hash;
};