此题为剑指offer的第7题 就是根据二叉树的前序和中序遍历的序列来构造二叉树并以层次遍历的形式输出。
考察了二叉树的遍历 。思想是前序遍历的第一个值就是数的root节点，然后去中序遍历中找这个数，以此数为间隔，前面的为root的左子树，后面的为root的右子树，然后之后就用同样的方法分别构建左右子树，所以可以使用递归来完成。 这里层次遍历输出方法是构建一个队列，将根节点入队，出队的时候打印根节点，若此节点有左右子节点，则将左右子节点按顺序入队，直到队列为空时，所有节点都应经入队并出队。
实现代码如下

import java.util.Arrays;
import java.util.LinkedList;

class TreeNode{
    TreeNode left,right;
    int value;
    public TreeNode(int value) {
        super();
        this.left = this.right =null;
        this.value = value;
    }   
}
public class Test7 {
    public static void main(String[] args) throws Exception{
        int[] foward = {1,2,4,7};
        int[] middle = {4,7,3,1};
        TreeNode newTree = getNewTree(foward,middle);
        printTree(newTree);
    }
    
    public static TreeNode getNewTree(int[] preorder,int[] inorder) throws Exception{
        if(preorder.length<=0 ||inorder.length<=0){
            return null;
        }
        TreeNode root = new TreeNode(preorder[0]);//preorder是前序遍历的序列，0位置上是根节点
        int index =  getindex(inorder, preorder[0]);//inorder中根节点的位置，前面的为左子树，后边的为右子树
        if(index==-1){
            throw new Exception("序列不匹配");
        }
        if(preorder.length==1){
            return root;
        }
        int[] left = Arrays.copyOfRange(inorder, 0, index);
        int[] right = Arrays.copyOfRange(inorder, index+1, inorder.length);
        
        int[] newpreleft = Arrays.copyOfRange(preorder, 1, index+1);
        int[] newpreright = Arrays.copyOfRange(preorder, preorder.length-index-1, preorder.length);
        
        if(left.length>0){
            root.left = getNewTree(newpreleft,left);    
        }
        if(right.length>0){
            root.right = getNewTree(newpreright, right);
        }
        return root;
    }
    public static int getindex(int arr[],int number){

        for(int i=0;i<arr.length;i++){
            if(arr[i]==number){
                return i;
            }
        }
        return -1;
    }
    public static void printTree(TreeNode root){
        {
              if(root == null)
              {
                  return ;
              }
              LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
              TreeNode current = null;
              queue.offer(root);//将根节点入队
              while(!queue.isEmpty())
              {
                  current = queue.poll();//出队队头元素并访问
                  System.out.print(current.value +"-->");
                  if(current.left != null)//如果当前节点的左节点不为空入队
                  {
                      queue.offer(current.left);
                  }
                  if(current.right != null)//如果当前节点的右节点不为空，把右节点入队
                  {
                      queue.offer(current.right);
                  }
              }
              
        }
    }

}