重建二叉树

总结：

1.通过画图找到规律：

　　1.1先序遍历的第一个元素是根结点。

　　1.2.通过中序遍历找到左子树元素数目。

2.注意边界条件，如树为空的情况。

3.第二中解法一开始想不到递归出口，画完图明白了，一定要画图画图画图！

4.可以通过逐段注释的方式，定位bug。

5.第二中解法一直找不到bug，重新写了一遍，没问题了2333333

 

下面是两种解法：

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) {
        TreeNode * root = new TreeNode; 
        if(preorder.size()==0)
            return NULL;
        root->val = preorder[0];
        int num =0;
        int len = preorder.size();
        int i =0;
        while(inorder[i] !=  preorder[0])
        {
            num++;
            i++;
        }
        vector<int> lpre(preorder.begin()+1,preorder.begin()+1+num);
        vector<int> lin(inorder.begin(),inorder.begin()+num);
        root->left = buildTree(lpre,lin);

        vector<int>rpre(preorder.begin()+1+num,preorder.end());
        vector<int>rin(inorder.begin()+num+1,inorder.end());
        root->right = buildTree(rpre,rin);

        return root;
    }
};

 

2.优化的解法

1.通过哈希快速定位根结点位置，中序遍历中元素的值作为【键】，下标作为【值】

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 {
private:
    unordered_map<int,int> index;
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        int len = preorder.size();
        for(int i =0;i<len;i++)
            index[inorder[i]] = i;
        if(len == 0)
            return NULL;
        else
            return build(preorder,inorder,0,len-1,0,len-1);
    }
    TreeNode * build(vector<int>& preorder,vector<int>& inorder,int pre_begin,int pre_end,int in_begin,int in_end)
    {
        TreeNode * root = new TreeNode;
        root->val = preorder[pre_begin];
        int root_pos = index[root->val];
        //left subtree size
        int num = root_pos - in_begin;
        
        if(num != 0)
            root->left = build(preorder,inorder,pre_begin+1,pre_begin + num,in_begin,root_pos-1);
        else 
            root->left = NULL;
        
        
        if( (pre_end - pre_begin + 1 - num -1) != 0)
            root->right = build(preorder,inorder,pre_begin+num+1,pre_end,root_pos+1,in_end);
        else 
            root->right =  NULL;
            
        
        return root;
    }
};