Java implementation of two fork tree construction and traversal

Reprint: http://ocaicai.iteye.com/blog/1047397

Directory:

1. Assign the value of an array to a binary tree

2. Specific code


1. How to build a tree



2. Specific code

Java code

2. Package tree;
6. Import java.util.LinkedList;
8. Import java.util.List;
12. /**
14. * Function: The value of an array is stored in a two-fork tree and then traversed in 3 ways
16. *
18. * Reference 0: Data structure (c language version) Min
20. *
22. * Reference 1:http://zhidao.baidu.com/question/81938912.html
24. *
26. * Reference 2:http://cslibrary.stanford.edu/110/binarytrees.html#java
28. *
30. * @author [email protected] @date: 2011-5-17
32. *
34. */
36. Public class BinTreeTraverse2 {
40. private int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9};
42. private static list<node> nodeList = null;
46. /** 
48. * Inner class: node
50. *
52. * @author [email protected] @date: 2011-5-17
54. *
56. */
58. private static class Node {
60. Node Leftchild;
62. Node Rightchild;
64. int data;
68. Node (int newdata) {
70. Leftchild = null;
72. Rightchild = null;
74. data = NewData;
76. }
78. }
82. public void Createbintree () {
84. NodeList = new linkedlist<node> ();
86. //Convert the values of an array to node nodes in turn
88. For (int nodeindex = 0; nodeindex < array.length; nodeindex++) {
90. Nodelist.add (new Node (Array[nodeindex));
92. }
94. //To the first LastParentIndex-1 parent node establish a two-fork tree based on the number relationship of the parent node to the child node
96. For (int parentindex = 0; parentindex < array.length/ 2- 1; parentindex++) {
98. //Left child
100. Nodelist.get (parentindex). Leftchild = NodeList
102. . Get (Parentindex * 2 + 1);
104. //Right child
106. Nodelist.get (parentindex). Rightchild = NodeList
108. . Get (Parentindex * 2 + 2);
110. }
112. ///Last parent node: Because the last parent node may not have a right child, so take it out alone
114. int lastparentindex = array.length/ 2- 1;
116. //Left child
118. Nodelist.get (lastparentindex). Leftchild = NodeList
120. . Get (Lastparentindex * 2 + 1);
122. //Right child, if the array length is odd to establish right child
124. if (array.length% 2 = = 1) {
126. Nodelist.get (lastparentindex). Rightchild = NodeList
128. . Get (Lastparentindex * 2 + 2);
130. }
132. }
136. /** 
138. * First Order traversal
140. *
142. * These three different traversal structures are the same, but the order is not the same
144. *
146. * @param node
148. * Traversed nodes
150. */
152. public static void Preordertraverse (node node) {
154. if (node = = null)
156. return;
158. System.out.print (Node.data + "");
160. Preordertraverse (Node.leftchild);
162. Preordertraverse (Node.rightchild);
164. }
168. /** 
170. * Middle Sequence traversal
172. *
174. * These three different traversal structures are the same, but the order is not the same
176. *
178. * @param node
180. * Traversed nodes
182. */
184. public static void Inordertraverse (node node) {
186. if (node = = null)
188. return;
190. Inordertraverse (Node.leftchild);
192. System.out.print (Node.data + "");
194. Inordertraverse (Node.rightchild);
196. }
200. /** 
202. * Post-sequential traversal
204. *
206. * These three different traversal structures are the same, but the order is not the same
208. *
210. * @param node
212. * Traversed nodes
214. */
216. public static void Postordertraverse (node node) {
218. if (node = = null)
220. return;
222. Postordertraverse (Node.leftchild);
224. Postordertraverse (Node.rightchild);
226. System.out.print (Node.data + "");
228. }
232. public static void Main (string[] args) {
234. BinTreeTraverse2 bintree = new BinTreeTraverse2 ();
236. Bintree.createbintree ();
238. the value at No. 0 index in//nodelist is the root node
240. Node root = Nodelist.get (0);
244. System.out.println ("First Order traversal:");
246. Preordertraverse (root);
248. System.out.println ();
252. System.out.println ("Middle sequence Traversal:");
254. Inordertraverse (root);
256. System.out.println ();
260. System.out.println ("post-posttraversal:");
262. Postordertraverse (root);
264. }
268. }

Output Result:

Java code

2. First-order Traversal:
4. 1 2 4 8 9 5 3 6 7
6. Middle Sequence Traversal:
8. 8 4 9 2 5 1 6 3 7
10. Post-post traversal:
12. 8 9 4 5 2 6 7 3 1
    

Java implementation of two fork tree construction and traversal