劍指Offer面試題6：重建二叉樹 Java實現

題目：重建二叉樹

          輸入某二叉樹的前序遍歷和中序遍歷的結果，請重建出該二叉樹。假設輸入的前序遍歷和中序遍歷的結果中都不含重複數字。例如，輸入前序遍歷序列{1,2,4,7,3,5,6,8}和中序遍歷序列{4,7,2,1,5,3,8,6}，則重建出圖中所示的二叉樹並輸出它的頭節點。

算法分析：

在二叉樹的前序遍歷序列中，第一個數字總是樹的根節點的值。但在中序遍歷中，根節點的值在序列的中間，左子樹的結點的值位於根節點的值的左邊，而右子樹的結點的值位於根節點的右邊。因此我們需要掃描中序遍歷序列，才能找到根節點的值。

 

如圖所示，前序遍歷序列的第一個數字1就是根節點的值。掃描中序遍歷序列，就能確定根節點的值的位置。根據中序遍歷的特點，在根節點的值1前面3個數字都是左子樹結點的值，位於1後面的數字都是右子樹結點的值。

 

由於中序遍歷序列中，有3個數字是左子樹結點的值，因此左子樹總共有3個左子結點。同樣，在前序遍歷的序列中，根節點後面的3個數字就是3個左子樹結點的值，再後面的所有數字都是右子樹結點的值。這樣我們就在前序遍歷和中序遍歷兩個序列中，分別找到了左右子樹對應的子序列。

 

 

既然我們已經分別找到了左、右子樹的前序遍歷序列和中序遍歷序列，我們可以用同樣的方法分別去構建左右子樹。也就是說，接下來的事情可以用遞歸的方法去完成。

算法源程序；

1. /**************************************************************
2. * Copyright (c) 2016, 北京郵電大學
3. * All rights reserved.
4. * 版 本 號：v1.0
5. * 題目描述：重建二叉樹
6. * 輸入某二叉樹的前序遍歷和中序遍歷的結果，請重建出該二叉樹。假設輸入的前序遍歷和中序遍歷的結果中都不含重複數字。
7. * 例如，輸入前序遍歷序列{1,2,4,7,3,5,6,8}和中序遍歷序列{4,7,2,1,5,3,8,6}，則重建出圖中所示的二叉樹並輸出它的頭節點。
8. * 輸入描述：無
9. * 程序輸出： 4 7 2 1 5 3 8 6 Exception in thread "main"
10. * 5 4 3 2 1
11. * 1 2 3 4 5
12. * 1
13. * 4 2 5 1 6 3 7
14. * 問題分析：無
15. * 算法描述：無
16. * 完成時間：2016-10-30
17. ***************************************************************/
19. package org.marsguo.offerproject06;
20. /*
21. 定義二叉樹節點
22. */
23. class TreeNode{
24. int val;
25. public TreeNode left = null;
26. public TreeNode right = null;
27. }
29. class SolutionMethod1{
30. /**
31. * 輸入某二叉樹的前序遍歷和中序遍歷的結果，請重建出該二節樹。假設輸入的前序遍歷和中序遍歷的結果中都不含重複的數字。
32. *
33. * @param preorder 前序遍歷
34. * @param inorder 中序遍歷
35. * @return 樹的根結點
36. */
37. public TreeNode BinaryTreeFunction(int[] preorder,int[] inorder){
38. if(preorder == null || inorder == null ||
39. preorder.length != inorder.length || inorder.length < 1){
40. return null;
41. }
43. return ConstructCore(preorder,0,preorder.length - 1,inorder,0,inorder.length - 1);
44. }
46. /**
47. * 輸入某二叉樹的前序遍歷和中序遍歷的結果，請重建出該二節樹。假設輸入的前序遍歷和中序遍歷的結果中都不含重複的數字。
48. *
49. * @param preorder 前序遍歷
50. * @param ps 前序遍歷的開始位置
51. * @param pe 前序遍歷的結束位置
52. * @param inorder 中序遍歷
53. * @param is 中序遍歷的開始位置
54. * @param ie 中序遍歷的結束位置
55. * @return 樹的根結點
56. */
57. public TreeNode ConstructCore(int[] preorder, int ps, int pe, int[] inorder, int is, int ie){
58. if(ps > pe){ //開始位置大於結束位置，說明已經沒有需要處理的元素了
59. return null;
60. }
61. int value = preorder[ps]; // 取前序遍歷的第一個數字，就是當前的根結點
62. int index = is;
63. while(index <= ie && inorder[index] != value){ // 在中序遍歷的數組中找根結點的位置
64. index++;
65. }
67. if(index > ie){ // 如果在整個中序遍歷的數組中沒有找到，說明輸入的參數是不合法的，拋出異常
68. throw new RuntimeException("Invalid input");
69. }
71. TreeNode node = new TreeNode(); // 創建當前的根結點，並且爲結點賦值
72. node.val = value;
74. /*
75. 遞歸構建當前根結點的左子樹，左子樹的元素個數：index-is+1個
76. 左子樹對應的前序遍歷的位置在[ps+1, ps+index-is]
77. 左子樹對應的中序遍歷的位置在[is, index-1]
78. */
79. node.left = ConstructCore(preorder, ps + 1, ps + index - is, inorder, is, index - 1);
81. /*遞歸構建當前根結點的右子樹，右子樹的元素個數：ie-index個
82. 右子樹對應的前序遍歷的位置在[ps+index-is+1, pe]
83. 右子樹對應的中序遍歷的位置在[index+1, ie]
84. */
85. node.right = ConstructCore(preorder, ps + index - is + 1, pe, inorder, index + 1, ie);
87. // 返回創建的根結點
88. return node;
89. }
91. public void printTree(TreeNode root){ // 中序遍歷二叉樹
92. if(root != null){
93. printTree(root.left);
94. System.out.print(root.val + " ");
95. printTree(root.right);
96. }
97. //System.out.println();
98. }
100. // 普通二叉樹
101. // 1
102. // / \
103. // 2 3
104. // / / \
105. // 4 5 6
106. // \ /
107. // 7 8
108. public void test1() {
109. int[] preorder = {1, 2, 4, 7, 3, 5, 6, 8};
110. int[] inorder = {4, 7, 2, 1, 5, 3, 8, 6};
111. TreeNode root = BinaryTreeFunction(preorder, inorder);
112. printTree(root);
113. }
115. // 所有結點都沒有右子結點
116. // 1
117. // /
118. // 2
119. // /
120. // 3
121. // /
122. // 4
123. // /
124. // 5
125. public void test2() {
126. int[] preorder = {1, 2, 3, 4, 5};
127. int[] inorder = {5, 4, 3, 2, 1};
128. TreeNode root = BinaryTreeFunction(preorder, inorder);
129. printTree(root);
130. }
132. // 所有結點都沒有左子結點
133. // 1
134. // \
135. // 2
136. // \
137. // 3
138. // \
139. // 4
140. // \
141. // 5
142. public void test3() {
143. int[] preorder = {1, 2, 3, 4, 5};
144. int[] inorder = {1, 2, 3, 4, 5};
145. TreeNode root = BinaryTreeFunction(preorder, inorder);
146. printTree(root);
147. }
149. // 樹中只有一個結點
150. public void test4() {
151. int[] preorder = {1};
152. int[] inorder = {1};
153. TreeNode root = BinaryTreeFunction(preorder, inorder);
154. printTree(root);
155. }
157. // 完全二叉樹
158. // 1
159. // / \
160. // 2 3
161. // / \ / \
162. // 4 5 6 7
163. public void test5() {
164. int[] preorder = {1, 2, 4, 5, 3, 6, 7};
165. int[] inorder = {4, 2, 5, 1, 6, 3, 7};
166. TreeNode root = BinaryTreeFunction(preorder, inorder);
167. printTree(root);
168. }
170. // 輸入空指針
171. public void test6() {
172. BinaryTreeFunction(null, null);
173. }
175. // 輸入的兩個序列不匹配
176. public void test7() {
177. int[] preorder = {1, 2, 4, 5, 3, 6, 7};
178. int[] inorder = {4, 2, 8, 1, 6, 3, 7};
179. TreeNode root = BinaryTreeFunction(preorder, inorder);
180. printTree(root);
181. }
182. }
184. public class RebuildBinaryTree {
185. public static void main(String[] args){
186. SolutionMethod1 solution1 = new SolutionMethod1();
187. solution1.test1();
188. System.out.println();
189. solution1.test2();
190. System.out.println();
191. solution1.test3();
192. System.out.println();
193. solution1.test4();
194. System.out.println();
195. solution1.test5();
196. System.out.println();
197. solution1.test6();
198. System.out.println();
199. solution1.test7();
200. System.out.println();
201. }
202. }

程序運行結果