1问题

给定二叉树的2个遍历序列（如先根+中根，先根+后根，中根+后根等），是否能够根据这2个遍历序列唯一确定二叉树？

2结论

3理论分析

前序遍历的第一个元素为根节点，在中序遍历中找到这个根节点，从而可以将中序遍历分为左右两个部分，左边部分为左子树的中序遍历，右边部分为右子树的中序遍历，进而也可以将前序遍历除第一个元素以外的剩余部分分为两个部分，第一个部分为左子树的前序遍历，第二个部分为右子树的前序遍历。 

由上述分析结果，可以递归调用构建函数，根据左子树、右子树的前序、中序遍历的结果输出后序遍历的结果。 

view plain

1. //根据前序遍历和中序遍历重建二叉树的Java实现   
2.   
3. class Node {    
4.     Node left = null;    
5.     Node right = null;    
6.     char value;    
7. }    
8. public class BinaryTreeBuilder {    
9.     /**  
10.      * 根据前序遍历和中序遍历重建二叉树子树  
11.      * @param preOrder 前序遍历数组  
12.      * @param start 子树起始位置  
13.      * @param inOrder 中序遍历数组  
14.      * @param end 中序遍历结束位置  
15.      * @param length 节点数  
16.      * @return 树的根节点  
17.      */    
18.  public static Node buildTree(char[] preOrder,int start, char[] inOrder,int end,int length){    
19.         //参数验证     
20.         if (preOrder == null || preOrder.length == 0 || inOrder == null    
21.                 || inOrder.length == 0 || length <= 0) {    
22.             return null;    
23.         }    
24.             
25.         //根据前序遍历的第一个元素建立树根节点     
26.         char value = preOrder[start];    
27.         Node root = new Node();    
28.         root.value = value;    
29.             
30.         //递归终止条件：子树只有一个节点     
31.         if (length == 1)    
32.             return root;    
33.             
34.         //根据前序遍历的第一个元素在中序遍历中的位置分拆树的左子树和右子树     
35.         int i = 0;    
36.         while (i < length) {    
37.             if (value == inOrder[end - i]) {    
38.                 break;    
39.             }    
40.             i++;    
41.         }    
42.             
43.         //建立子树的左子树     
44.     root.left = buildTree(preOrder, start + 1, inOrder, end - i - 1, length - 1 - i);    
45.         //建立子树的右子树     
46.     root.right = buildTree(preOrder, start + length - i, inOrder, end, i );    
47.             
48.         return root;    
49.     }    
50.   
51.    // 后序遍历二叉树  
52.     private static void postOrder(Node root) {  
53.         if (root == null) {  
54.             return;  
55.         }  
56.         postOrder(root.left);  
57.         postOrder(root.right);  
58.         System.out.print(root.value+"  ");  
59.     }  
60.   
61.   
62.     public static void main(String[] args) {   
63.         //char[] preOrder = new char[] {'1', '2', '4', '5', '3', '6'};    
64.         char[] preOrder = new char[] {'A', 'B', 'D', 'E', 'G', 'H','J','C','F','I'};    
65.         //char[] inOrder = new char[] {'4', '2', '5', '1', '6', '3'};    
66.         char[] inOrder = new char[] {'D', 'B', 'G', 'E', 'H', 'J','A','C','I','F'};    
67.         Node root = buildTree(preOrder, 0, inOrder, inOrder.length - 1, inOrder.length);    
68.         postOrder(root);  
69.     }    
70. }    

运行结果： 
D  G  J  H  E  B  I  F  C  A