已知先序遍历和中序遍历求解二叉树

先序遍历：根节点-->左子树-->右子树

中序遍历：左子树-->根节点-->右子树

根据先序遍历和中序遍历求解二叉树步骤：

① 确定根节点。先序遍历中的第一个节点就是二叉树的根节点，然后根据根节点数值求出其在中序遍历中的位置。

② 求解二叉树的左右子树。根据根节点在中序遍历中的位置，位置左边的为左子树，位置右边的为右子树。如果根节点位置左边或右边为空，则该方向的子树为空；如果根节点左右两边均为空，则根节点为叶子节点。

③ 采用递归方法，对二叉树的左、右子树分别进行步骤①和②，直到获得二叉树。

代码如下：

//树节点类
class Node{
	public int data;//节点的数值
	public Node left;//左子节点
	public Node right;//右子节点
	//构造函数
	public Node(){
		
	}
	public Node(int data){
		this.data=data;
		this.left=null;
		this.right=null;
	}
}

遍历方法，用于测试构建的二叉树是否正确

//二叉树遍历类
class OrderBinTree{
	/*
	 * 先序遍历-->根节点，左子树，右子树（递归实现）
	 */
	public static void preOrder(Node root){
		if(root!=null){
			System.out.print(root.data+" ");//输出根节点数值
			preOrder(root.left);//左子树
			preOrder(root.right);//右子树
		}
	}
	
	/*
	 * 中序遍历-->左子树，根节点，右子树（递归实现）
	 */
	public static void inOrder(Node root){
		if(root!=null){
			inOrder(root.left);//左子树
			System.out.print(root.data+" ");//输出根节点数值
			inOrder(root.right);//右子树
		}
	}
	
	/*
	 * 后序遍历-->左子树，右子树，根节点（递归实现）
	 */
	public static void postOrder(Node root){
		if(root!=null){
			postOrder(root.left);//左子树
			postOrder(root.right);//右子树
			System.out.print(root.data+" ");//输出根节点数值
		}
	}
	
	/*
	 * 层次遍历（采用队列实现）
	 */
	public static void layerOrder(Node root){
		if(root!=null){
			Queue<Node> q=new LinkedList<Node>();
			q.add(root);
			while(!q.isEmpty()){ //当前队列不为空
				Node n=q.poll();
				System.out.print(n.data+" ");
				if(n.left!=null){
					q.add(n.left);
				}
				if(n.right!=null){
					q.add(n.right);
				}
			}
		}
	}
}

构建二叉树，并进行测试

public class CreateBinTree {

	private static Node root;
	
	//根据先序遍历结果和中序遍历结果构造二叉树（根节点数值唯一）
	public static Node createBinaryTree(int[] preOrder,int preStart,int preEnd,int[] inOrder,int inStart,int inEnd)
	{
		if(preOrder.length==0||inOrder.length==0||preOrder==null||inOrder==null||preOrder.length!=inOrder.length||preStart>preEnd||inStart>inEnd)
			return null;
		int data =preOrder[preStart];//先序遍历第一个值为根节点的值
		Node root=new Node(data);//根据根节点的值构造根节点
		//找到中序遍历中根节点的位置
		int rootIndex=0;
		for(rootIndex=inStart;rootIndex<=inEnd;rootIndex++){
			if(inOrder[rootIndex]==data)
				break;
		}			
		/*
		 * 递归求解左子树: 左子树先序开始 preStart+1， 左子树先序结束 (rootIndex-inStart)+preStart
		 *                左子树中序开始 inStart， 左子树中序结束 rootIndex-1
		 */
		Node left=createBinaryTree(preOrder,preStart+1,rootIndex-inStart+preStart,inOrder,inStart,rootIndex-1);
		
		/*
		 * 递归求解右子树：右子树先序开始 preStart+rootIndex-inStart+1， 右子树先序结束 preEnd
		 * 				    右子树中序开始 rootIndex+1, 右子树中序结束 inEnd
		 */
		Node right=createBinaryTree(preOrder,preStart+rootIndex-inStart+1,preEnd,inOrder,rootIndex+1,inEnd);
		root.left=left;
		root.right=right;
		return root;
	}	
	 public static void main(String[] args) {
		 int preOrder[] = {2,1,8,7,4,3,6,5,7,9};
	     int inOrder[]  = {1,2,3,4,5,6,7,7,8,9};
	     root=createBinaryTree(preOrder,0,preOrder.length-1,inOrder,0,inOrder.length);
	   //先序遍历
		System.out.print("先序遍历： ");
		OrderBinTree.preOrder(root);
		System.out.println();
		//中序遍历
		System.out.print("中序遍历： ");
		OrderBinTree.inOrder(root);
		System.out.println();
		//后序遍历
		System.out.print("后序遍历： ");
		OrderBinTree.postOrder(root);
		System.out.println();
		//层次遍历
		System.out.print("层次遍历： ");
		OrderBinTree.layerOrder(root);
	}
}