二叉樹的定義：

二叉樹是樹形結構的一個重要類型。許多實際問題抽象出來的數據結構往往是二叉樹的形式，即使是一般的樹也能簡單地轉換為二叉樹，而且二叉樹的存儲結構及其算法都較為簡單，因此二叉樹顯得特別重要。
二叉樹(BinaryTree)是n(n≥0)個結點的有限集，它或者是空集(n=0)，或者由一個根結點及兩棵互不相交的、分別稱作這個根的左子樹和右子樹的二叉樹組成。
這個定義是遞歸的。由於左、右子樹也是二叉樹， 因此子樹也可為空樹。

二叉樹的遍歷

對於二叉樹來講最主要、最基本的運算是遍歷。
遍歷二叉樹 是指以一定的次序訪問二叉樹中的每個結點。所謂 訪問結點 是指對結點進行各種操作的簡稱。例如，查詢結點數據域的內容，或輸出它的值，或找出結點位置，或是執行對結點的其他操作。遍歷二叉樹的過程實質是把二叉樹的結點進行線性排列的過程。假設遍歷二叉樹時訪問結點的操作就是輸出結點數據域的值，那麽遍歷的結果得到一個線性序列。

從二叉樹的遞歸定義可知，一棵非空的二叉樹由根結點及左、右子樹這三個基本部分組成。因此，在任一給定結點上，可以按某種次序執行三個操作：
　（1）訪問結點本身(N)，
　（2）遍歷該結點的左子樹(L)，
　（3）遍歷該結點的右子樹(R)。
以上三種操作有六種執行次序：
　NLR、LNR、LRN、NRL、RNL、RLN。
註意：
前三種次序與後三種次序對稱，故只討論先左後右的前三種次序。
　　由於被訪問的結點必是某子樹的根，所以N(Node)、L(Left subtlee)和R(Right subtree)又可解釋為根、根的左子樹和根的右子樹。NLR、LNR和LRN分別又稱為先根遍歷、中根遍歷和後根遍歷。

二叉樹的java實現

java實現代碼：

2. import java.util.Stack;
4. /**
5. * 二叉樹的鏈式存儲
6. * @author WWX
7. */
8. public class BinaryTree {
11. private TreeNode root=null;
13. public BinaryTree(){
14. root=new TreeNode(1,"rootNode(A)");
15. }
17. /**
18. * 創建一棵二叉樹
19. * <pre>
20. * A
21. * B C
22. * D E F
23. * </pre>
24. * @param root
25. * @author WWX
26. */
27. public void createBinTree(TreeNode root){
28. TreeNode newNodeB = new TreeNode(2,"B");
29. TreeNode newNodeC = new TreeNode(3,"C");
30. TreeNode newNodeD = new TreeNode(4,"D");
31. TreeNode newNodeE = new TreeNode(5,"E");
32. TreeNode newNodeF = new TreeNode(6,"F");
33. root.leftChild=newNodeB;
34. root.rightChild=newNodeC;
35. root.leftChild.leftChild=newNodeD;
36. root.leftChild.rightChild=newNodeE;
37. root.rightChild.rightChild=newNodeF;
38. }
41. public boolean isEmpty(){
42. return root==null;
43. }
45. //樹的高度
46. public int height(){
47. return height(root);
48. }
50. //節點個數
51. public int size(){
52. return size(root);
53. }
56. private int height(TreeNode subTree){
57. if(subTree==null)
58. return 0;//遞歸結束：空樹高度為0
59. else{
60. int i=height(subTree.leftChild);
61. int j=height(subTree.rightChild);
62. return (i<j)?(j+1):(i+1);
63. }
64. }
66. private int size(TreeNode subTree){
67. if(subTree==null){
68. return 0;
69. }else{
70. return 1+size(subTree.leftChild)
71. +size(subTree.rightChild);
72. }
73. }
75. //返回雙親結點
76. public TreeNode parent(TreeNode element){
77. return (root==null|| root==element)?null:parent(root, element);
78. }
80. public TreeNode parent(TreeNode subTree,TreeNode element){
81. if(subTree==null)
82. return null;
83. if(subTree.leftChild==element||subTree.rightChild==element)
84. //返回父結點地址
85. return subTree;
86. TreeNode p;
87. //現在左子樹中找，如果左子樹中沒有找到，才到右子樹去找
88. if((p=parent(subTree.leftChild, element))!=null)
89. //遞歸在左子樹中搜索
90. return p;
91. else
92. //遞歸在右子樹中搜索
93. return parent(subTree.rightChild, element);
94. }
96. public TreeNode getLeftChildNode(TreeNode element){
97. return (element!=null)?element.leftChild:null;
98. }
100. public TreeNode getRightChildNode(TreeNode element){
101. return (element!=null)?element.rightChild:null;
102. }
104. public TreeNode getRoot(){
105. return root;
106. }
108. //在釋放某個結點時，該結點的左右子樹都已經釋放，
109. //所以應該采用後續遍歷，當訪問某個結點時將該結點的存儲空間釋放
110. public void destroy(TreeNode subTree){
111. //刪除根為subTree的子樹
112. if(subTree!=null){
113. //刪除左子樹
114. destroy(subTree.leftChild);
115. //刪除右子樹
116. destroy(subTree.rightChild);
117. //刪除根結點
118. subTree=null;
119. }
120. }
122. public void traverse(TreeNode subTree){
123. System.out.println("key:"+subTree.key+"--name:"+subTree.data);;
124. traverse(subTree.leftChild);
125. traverse(subTree.rightChild);
126. }
128. //前序遍歷
129. public void preOrder(TreeNode subTree){
130. if(subTree!=null){
131. visted(subTree);
132. preOrder(subTree.leftChild);
133. preOrder(subTree.rightChild);
134. }
135. }
137. //中序遍歷
138. public void inOrder(TreeNode subTree){
139. if(subTree!=null){
140. inOrder(subTree.leftChild);
141. visted(subTree);
142. inOrder(subTree.rightChild);
143. }
144. }
146. //後續遍歷
147. public void postOrder(TreeNode subTree) {
148. if (subTree != null) {
149. postOrder(subTree.leftChild);
150. postOrder(subTree.rightChild);
151. visted(subTree);
152. }
153. }
155. //前序遍歷的非遞歸實現
156. public void nonRecPreOrder(TreeNode p){
157. Stack<TreeNode> stack=new Stack<TreeNode>();
158. TreeNode node=p;
159. while(node!=null||stack.size()>0){
160. while(node!=null){
161. visted(node);
162. stack.push(node);
163. node=node.leftChild;
164. }
165. <span abp="507" style="font-size:14px;">while</span>(stack.size()>0){
166. node=stack.pop();
167. node=node.rightChild;
168. }
169. }
170. }
172. //中序遍歷的非遞歸實現
173. public void nonRecInOrder(TreeNode p){
174. Stack<TreeNode> stack =new Stack<BinaryTree.TreeNode>();
175. TreeNode node =p;
176. while(node!=null||stack.size()>0){
177. //存在左子樹
178. while(node!=null){
179. stack.push(node);
180. node=node.leftChild;
181. }
182. //棧非空
183. if(stack.size()>0){
184. node=stack.pop();
185. visted(node);
186. node=node.rightChild;
187. }
188. }
189. }
191. //後序遍歷的非遞歸實現
192. public void noRecPostOrder(TreeNode p){
193. Stack<TreeNode> stack=new Stack<BinaryTree.TreeNode>();
194. TreeNode node =p;
195. while(p!=null){
196. //左子樹入棧
197. for(;p.leftChild!=null;p=p.leftChild){
198. stack.push(p);
199. }
200. //當前結點無右子樹或右子樹已經輸出
201. while(p!=null&&(p.rightChild==null||p.rightChild==node)){
202. visted(p);
203. //紀錄上一個已輸出結點
204. node =p;
205. if(stack.empty())
206. return;
207. p=stack.pop();
208. }
209. //處理右子樹
210. stack.push(p);
211. p=p.rightChild;
212. }
213. }
214. public void visted(TreeNode subTree){
215. subTree.isVisted=true;
216. System.out.println("key:"+subTree.key+"--name:"+subTree.data);;
217. }
220. /**
221. * 二叉樹的節點數據結構
222. * @author WWX
223. */
224. private class TreeNode{
225. private int key=0;
226. private String data=null;
227. private boolean isVisted=false;
228. private TreeNode leftChild=null;
229. private TreeNode rightChild=null;
231. public TreeNode(){}
233. /**
234. * @param key 層序編碼
235. * @param data 數據域
236. */
237. public TreeNode(int key,String data){
238. this.key=key;
239. this.data=data;
240. this.leftChild=null;
241. this.rightChild=null;
242. }
245. }
248. //測試
249. public static void main(String[] args) {
250. BinaryTree bt = new BinaryTree();
251. bt.createBinTree(bt.root);
252. System.out.println("the size of the tree is " + bt.size());
253. System.out.println("the height of the tree is " + bt.height());
255. System.out.println("*******(前序遍歷)[ABDECF]遍歷*****************");
256. bt.preOrder(bt.root);
258. System.out.println("*******(中序遍歷)[DBEACF]遍歷*****************");
259. bt.inOrder(bt.root);
261. System.out.println("*******(後序遍歷)[DEBFCA]遍歷*****************");
262. bt.postOrder(bt.root);
264. System.out.println("***非遞歸實現****(前序遍歷)[ABDECF]遍歷*****************");
265. bt.nonRecPreOrder(bt.root);
267. System.out.println("***非遞歸實現****(中序遍歷)[DBEACF]遍歷*****************");
268. bt.nonRecInOrder(bt.root);
270. System.out.println("***非遞歸實現****(後序遍歷)[DEBFCA]遍歷*****************");
271. bt.noRecPostOrder(bt.root);
272. }
273. }
274. </span>

輸出結果

the size of the tree is 6
the height of the tree is 3
*******(前序遍歷)[ABDECF]遍歷*****************
key:1--name:rootNode(A)
key:2--name:B
key:4--name:D
key:5--name:E
key:3--name:C
key:6--name:F
*******(中序遍歷)[DBEACF]遍歷*****************
key:4--name:D
key:2--name:B
key:5--name:E
key:1--name:rootNode(A)
key:3--name:C
key:6--name:F
*******(後序遍歷)[DEBFCA]遍歷*****************
key:4--name:D
key:5--name:E
key:2--name:B
key:6--name:F
key:3--name:C
key:1--name:rootNode(A)
***非遞歸實現****(前序遍歷)[ABDECF]遍歷*****************
key:1--name:rootNode(A)
key:2--name:B
key:4--name:D
key:5--name:E
key:3--name:C
key:6--name:F
***非遞歸實現****(中序遍歷)[DBEACF]遍歷*****************
key:4--name:D
key:2--name:B
key:5--name:E
key:1--name:rootNode(A)
key:3--name:C
key:6--name:F
***非遞歸實現****(後序遍歷)[DEBFCA]遍歷*****************
key:4--name:D
key:5--name:E
key:2--name:B
key:6--name:F
key:3--name:C
key:1--name:rootNode(A)

數據結構與算法的學習-二叉樹