前序/后序+中序还原二叉树

/**
 * 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() || preorder.size()!= inorder.size())
            return nullptr;
        return construct(preorder,inorder,0,preorder.size()-1,0,inorder.size()-1);   

    }
    TreeNode* construct(vector<int>& preorder, vector<int>& inorder,int leftpre, int rightpre, int leftin, int rightin)
    {
        TreeNode* root = new TreeNode(preorder[leftpre]);
        int i = leftin;
        while(inorder[i] != preorder[leftpre])
            ++i;
        int len = i - leftin;
        // 左子树的先序遍历数组和中序遍历数组下标
        if(len!= 0 )
        {
            // 左子树构造，先序左子树下标(leftpre+1,len+leftpre)，中序左子树下标(leftin,i-1)
            root->left = construct(preorder,inorder,leftpre+1,len+leftpre,leftin,i-1);
        }
         // 右子树的先序遍历数组和中序遍历数组下标
        if(i <rightin)
        {
            // 右子树构造,先序右子树下标(len+leftpre+1,rightpre)，中序右子树下标(i+1,rightin)
            root->right = construct(preorder,inorder,len+leftpre+1,rightpre,i+1,rightin);
        }
        return root;
    }
    // 方法二：构造出每次遍历的左子树前序数组和中序数组，右子树前序数组和中序数组
    /*
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if(preorder.empty() || inorder.empty() || preorder.size()!= inorder.size())
            return nullptr;
            
        TreeNode* root = new TreeNode(preorder[0]);
        int i=0;
        
        while(inorder[i] != preorder[0])
            ++i;
        // 左子树的先序遍历数组和种序遍历数组
        if(i!= 0 )
        {
            vector<int> leftpreorder(i);
            vector<int> leftinorder(i);

            int k=0;
            for(int j =1;j<=i;++j)
                leftpreorder[k++] = preorder[j];
            
            k = 0;
            for(int j =0;j<i;++j)
                leftinorder[k++] = inorder[j];
            // 左子树构造
            root->left = buildTree(leftpreorder,leftinorder);
        }
         // 右子树的先序遍历数组和种序遍历数组
        if(i <inorder.size()-1)
        {
            vector<int> rightpreorder(preorder.size()-1-i);
            vector<int> rightinorder(inorder.size()-1-i);
            
            int k = 0;
            for(int j = i+1;j<preorder.size();++j)
                rightpreorder[k++] = preorder[j];
            
            k = 0;
            for(int j =i+1;j<inorder.size();++j)
               rightinorder[k++] = inorder[j];
            // 右子树构造
            root->right = buildTree(rightpreorder,rightinorder);
        }
        return root;
    }
    */
};