已知二叉树的前序和中序遍历，构建该二叉树

先说说原理吧：

1. 前序遍历的第一个节点必然是树的根节点
2. 通过第1个节点将中序遍历分割为两部分，左边的就是树的左子树的节点，右边就是树的右子树的节点
3. 重复1，2步，直至构建一颗完整的二叉树

  Java代码：

    

[java] view plain copy

1. // 前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}  
2.         public TreeNode reConstructBinaryTree(int[] pre, int[] in)  
3.             {  
4.                 if (pre == null || in == null || pre.length != in.length)  
5.                     return null;  
6.                 TreeNode pHeadNode = new TreeNode(pre[0]);  
7.                 int i = 0;  
8.                 for (i = 0; i < in.length; i++)  
9.                     if (pre[0] == in[i])  
10.                         break;  
11.                 pHeadNode.left = reConstructBinaryTree(pre, in, 1, 0, i - 1);  
12.                 pHeadNode.right = reConstructBinaryTree(pre, in, i + 1, i + 1,  
13.                         in.length - 1);  
14.                 return pHeadNode;  
15.             }  
16.         /** 
17.          * @param pre 前序遍历的数组 
18.          * @param in    中序遍历的数组 
19.          * @param mid  根节点的值 
20.          * @param start 子树的开始节点 
21.          * @param end 子树的开始节点 
22.          * @return 
23.          */  
24.         public TreeNode reConstructBinaryTree(int[] pre, int[] in, int mid,  
25.                 int start, int end)  
26.             {  
27.                 if (end < start)  
28.                     return null;  
29.                 TreeNode node = new TreeNode(pre[mid]);  
30.                 if (end == start)  
31.                     return node;  
32.                 int i = 0;  
33.                 for (i = start; i <= end; i++)  
34.                     if (pre[mid] == in[i])  
35.                         break;  
36.                 if (i == start)  
37.                     node.left = null;  
38.                 else  
39.                     node.left = reConstructBinaryTree(pre, in, mid + 1, start,  
40.                             i - 1);  
41.                 if (i == end)  
42.                     node.right = null;  
43.                 else  
44.                     node.right = reConstructBinaryTree(pre, in, mid + 1 + i  
45.                             - start, i + 1, end);  
46.                 return node;  
47.             }