105. Construct Binary Tree from Preorder and Inorder Traversal

主题思想： 经典题，二叉树的构建，利用前序和中序序列进行二叉树的构建。

首先采用递归的思想： 从前序序列找根节点，然后去中序序列里面找到根节点的下标，中序序列中在根节点之前的元素构成根节点的左子树节点，之后的构成右子树节点，递归下去。

中序序列以根节点为分界分成左右两个部分，这个容易理解，那在前序序列中，又如何分割为左右子树两个部分呢？

这个就需要计算在中序中，根节点左边有多少个节点是属于左子树的， 然后前序序列跳过这些节点后剩下的节点组成右子树。

中序序列中有多少个元素属于左子树呢，应该是根节点下标- 中序序列开始下标，

那什么时候应该返回null呢？ 当中序中找不到元素是为null，或者前序序列中找不到合法元素时为null。
AC 代码：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {


    public TreeNode buildTree(int[] preorder, int[] inorder) {

     return buildTreeRecursively(preorder,inorder,0,0,inorder.length-1);
    }

    public TreeNode buildTreeRecursively(int[] preorder,int [] inorder, int preStart,int inStart,int inEnd){

        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=buildTreeRecursively(preorder,inorder,preStart+1,inStart,inIndex-1);
        root.right=buildTreeRecursively(preorder,inorder,preStart+inIndex-inStart+1,inIndex+1,inEnd);
        return root;
    }
}

还有一种迭代解法：

思路是： 递归的从preorder 取出元素构建节点，有一个栈，记录父节点。

然后当栈顶与中序序列元素相等时，重置标记为，证明该构造右子树了

if(preorder.size()==0)
         return NULL;

     stack<int> s;
     stack<TreeNode *> st;
     TreeNode *t,*r,*root;
     int i,j,f;

     f=i=j=0;
     s.push(preorder[i]);

     root = new TreeNode(preorder[i]);
     st.push(root);
     t = root;
     i++;

     while(i<preorder.size())
     {
         if(!st.empty() && st.top()->val==inorder[j])
         {
             t = st.top();
             st.pop();
             s.pop();
             f = 1;
             j++;
         }
         else
         {
             if(f==0)
             {
                 s.push(preorder[i]);
                 t -> left = new TreeNode(preorder[i]);
                 t = t -> left;
                 st.push(t);
                 i++;
             }
             else 
             {
                 f = 0;
                 s.push(preorder[i]);
                 t -> right = new TreeNode(preorder[i]);
                 t = t -> right;
                 st.push(t);
                 i++;
             }
         }
     }

     return root;
 }