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

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

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

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

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

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

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

代码如下：
//树节点类
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();

4000
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);
}
}