construct binary tree from array

public TreeNode (int[] preorder, int[] inorder) {
    return helper(0, 0, inorder.length - 1, preorder, inorder);
}
public TreeNode helper(int preStart, int inStart, int inEnd, int[] preorder, int[] inorder) {
    if (preStart > preorder.length - 1 || inStart > inEnd) {
        return null;
    }
    TreeNode root = new TreeNode(preorder[preStart]);
    int inIndex = 0; 
    for (int i = inStart; i <= inEnd; i++) {
        if (inorder[i] == root.val) {
            inIndex = i;
        }
    }
    root.left = helper(preStart + 1, inStart, inIndex - 1, preorder, inorder);
    root.right = helper(preStart + inIndex - inStart + 1, inIndex + 1, inEnd, preorder, inorder);
    return root;
}

public TreeNode (int[] preorder, int[] inorder) {
    if(preorder == null || preorder.length == 0) return null;
    if(preorder.length != inorder.length) return null;
    Map<Integer, Integer> map = new HashMap<Integer, Integer>();
    for(int i = 0; i < inorder.length; i++)
        map.put(inorder[i], i);
    return dfs(preorder, 0, 0, preorder.length - 1, map);
}
private TreeNode dfs(int[] preorder, int left, int index, int right, Map<Integer, Integer> map) {
    if(left > right) return null;
    TreeNode root = new TreeNode(preorder[index]);
    int pos = map.get(preorder[index]);
    int leftsize = pos - left;
    TreeNode leftNode = dfs(preorder, left, index + 1, pos - 1, map);
    TreeNode rightNode = dfs(preorder, pos + 1, index + leftsize + 1, right, map);
    root.left = leftNode;
    root.right = rightNode;
    return root;
}

public TreeNode buildTreePostIn(int[] inorder, int[] postorder) {
	if (inorder == null || postorder == null || inorder.length != postorder.length)
		return null;
	HashMap<Integer, Integer> hm = new HashMap<Integer,Integer>();
	for (int i=0;i<inorder.length;++i)
		hm.put(inorder[i], i);
	return buildTreePostIn(inorder, 0, inorder.length-1, postorder, 0, 
                          postorder.length-1,hm);
}
private TreeNode buildTreePostIn(int[] inorder, int is, int ie, int[] postorder, int ps, int pe, 
                                 HashMap<Integer,Integer> hm){
	if (ps>pe || is>ie) return null;
	TreeNode root = new TreeNode(postorder[pe]);
	int ri = hm.get(postorder[pe]);
	TreeNode leftchild = buildTreePostIn(inorder, is, ri-1, postorder, ps, ps+ri-is-1, hm);
	TreeNode rightchild = buildTreePostIn(inorder,ri+1, ie, postorder, ps+ri-is, pe-1, hm);
	root.left = leftchild;
	root.right = rightchild;
	return root;
}

 public TreeNode (int[] inorder, int[] postorder) {
    if(postorder == null || postorder.length == 0) return null;
    if(inorder.length != postorder.length) return null;
    Map<Integer, Integer> map = new HashMap<Integer, Integer>();
    for(int i = 0; i < inorder.length; i++)
        map.put(inorder[i], i);
    return dfs(postorder, 0, postorder.length - 1, postorder.length - 1, map);
}
private TreeNode dfs(int[] postorder, int left, int right, int index, Map<Integer, Integer> map) {
    if(left > right) return null;
    if(index < 0) return null;
    TreeNode root = new TreeNode(postorder[index]);
    int pos = map.get(postorder[index]);
    int rightsize = right - pos;
    TreeNode leftNode = dfs(postorder, left, pos - 1, index - rightsize - 1, map);
    TreeNode rightNode = dfs(postorder, pos + 1, right, index - 1, map);
    root.left = leftNode;
    root.right = rightNode;
    return root;
}