Leetcode-Construct Binary Tree from inorder and postorder travesal

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

Solution:

 /**
  * Definition for binary tree
  * public class TreeNode {
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
  *     TreeNode(int x) { val = x; }
  * }
  */
 public class Solution {
     public TreeNode buildTree(int[] inorder, int[] postorder) {
          if (inorder.length==0)
                 return null;

             int len = inorder.length;
             TreeNode root = buildTreeRecur(inorder,postorder,0,len-1,0,len-1);
             return root;
     }

     //Build tree for current list, i.e., inorder[inHead] to inorder[inEnd].
     public TreeNode buildTreeRecur(int[] inorder, int[] postorder, int inHead, int inEnd, int postHead, int postEnd){
         if (inHead==inEnd){
                 TreeNode root = new TreeNode(inorder[inHead]);
                 return root;
             }

             int curRoot = postorder[postEnd];
             int index = -1;
             for (int i=inHead;i<=inEnd;i++)
                 if (inorder[i]==curRoot){
                     index = i;
                     break;
                 }
             int leftNodeNum = index-inHead;

             int leftInHead = inHead;
             int leftInEnd = inHead+leftNodeNum-1;
             int rightInHead = index+1;
             int rightInEnd = inEnd;      

             int leftPostHead = postHead;
             int leftPostEnd = postHead+leftNodeNum-1;
             int rightPostHead = leftPostEnd+1;
             int rightPostEnd = postEnd-1;

             TreeNode root = new TreeNode(curRoot);
             TreeNode leftChild = null;
             if (leftInEnd>=inHead){
                 leftChild = buildTreeRecur(inorder,postorder,leftInHead,leftInEnd,leftPostHead,leftPostEnd);
                 root.left = leftChild;
             }

             TreeNode rightChild = null;
             if (rightInHead<=inEnd){
                 rightChild = buildTreeRecur(inorder,postorder,rightInHead,rightInEnd,rightPostHead,rightPostEnd);
                 root.right = rightChild;
             }

             return root;
     }
 }

We need to be very carefull about how to count the start and end of the left sub-tree and the right-sub tree. Especially detecting the case that some sub-tree is void.

A better way is to calculate the number of nodes in left and right tree first, then find out the range, like this:

 /**
  * Definition for binary tree
  * public class TreeNode {
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
  *     TreeNode(int x) { val = x; }
  * }
  */
 public class Solution {
     public TreeNode buildTree(int[] inorder, int[] postorder) {
          if (inorder.length==0)
                 return null;

             int len = inorder.length;
             TreeNode root = buildTreeRecur(inorder,postorder,0,len-1,0,len-1);
             return root;
     }

     //Build tree for current list, i.e., inorder[inHead] to inorder[inEnd].
     public TreeNode buildTreeRecur(int[] inorder, int[] postorder, int inHead, int inEnd, int postHead, int postEnd){
         if (inHead==inEnd){
                 TreeNode root = new TreeNode(inorder[inHead]);
                 return root;
             }

             int curRoot = postorder[postEnd];
             TreeNode root = new TreeNode(curRoot);
             TreeNode leftChild = null;
             TreeNode rightChild = null;

             int index = -1;
             for (int i=inHead;i<=inEnd;i++)
                 if (inorder[i]==curRoot){
                     index = i;
                     break;
                 }
             int leftNodeNum = index-inHead;
             int rightNodeNum = inEnd-index;

             if (leftNodeNum>0){
                 int leftInHead = inHead;
                 int leftInEnd = inHead+leftNodeNum-1;
                 int leftPostHead = postHead;
                 int leftPostEnd = postHead+leftNodeNum-1;
                 leftChild = buildTreeRecur(inorder,postorder,leftInHead,leftInEnd,leftPostHead,leftPostEnd);
                 root.left = leftChild;
             }

             if (rightNodeNum>0){
                 int rightInHead = index+1;
                 int rightInEnd = inEnd;
                 int rightPostHead = postEnd-rightNodeNum;
                 int rightPostEnd = postEnd-1;
                 rightChild = buildTreeRecur(inorder,postorder,rightInHead,rightInEnd,rightPostHead,rightPostEnd);
                 root.right = rightChild;
             }

             return root;
     }
 }