Construct Binary Tree from Preorder and Inorder Traversal

/*

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.

*/
/**
 * 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 *BuildSubTree(vector<int> preorder, int & n, map<int,int> hashMap, int lowIdx, int highIdx){
      if(lowIdx>highIdx) return NULL;
      if(n>(preorder.size()-1)) return NULL;
     
      TreeNode *node;
   node = new TreeNode(preorder[n]);
   n++;
      if(lowIdx==highIdx){
         return node;
      }
     
      int index = hashMap[node->val];
     
      node->left = BuildSubTree(preorder, n, hashMap, lowIdx, index-1);
      node->right = BuildSubTree(preorder, n, hashMap, index+1, highIdx);
     
      return node;
    }
   
    TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        int size = preorder.size();
        if(size==0) return NULL;
        if(size!=inorder.size()) return NULL;
       
        map<int,int> hashMap;
        int i;
        for(i=0;i<size;i++){
          hashMap[inorder[i]] = i;
        }
       
        int n = 0;
        return BuildSubTree(preorder, n, hashMap, 0, size-1);
    }
};

//another solution:
/**
 * 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 *BuildSubTree(vector<int> preorder, map<int,int> hashMap, int lowIdx, int highIdx){
      static int n = 0;
        
      if(lowIdx>highIdx) return NULL;
      //if(n>(preorder.size()-1)) return NULL;
     
      TreeNode *node;
      node = new TreeNode(preorder[n]);
      n++;
     
      if(lowIdx==highIdx){
         return node;
      }
     
      int index = hashMap[node->val];
     
      node->left = BuildSubTree(preorder, hashMap, lowIdx, index-1);
      node->right = BuildSubTree(preorder, hashMap, index+1, highIdx);
     
      return node;
    }
   
    TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        int size = preorder.size();
        if(size==0) return NULL;
        if(size!=inorder.size()) return NULL;
       
        map<int,int> hashMap;
        int i;
        for(i=0;i<size;i++){
          hashMap[inorder[i]] = i;
        }
       
        return BuildSubTree(preorder, hashMap, 0, size-1);
    }
};