二叉树的java实现

下面是实现的具体代码，输入是工程目录下input.txt，文件，输入时“#”表示节点为空。

[java]  view plain copy

1. package com.algorithm.tree;  
2.   
3. import java.io.File;  
4. import java.io.FileNotFoundException;  
5. import java.util.Queue;  
6. import java.util.Scanner;  
7. import java.util.Stack;  
8. import java.util.concurrent.LinkedBlockingQueue;  
9.   
10.   
11. public class Tree<T> {  
12.   
13.     private Node<T> root;  
14.       
15.     public Tree() {  
16.     }  
17.       
18.     public Tree(Node<T> root) {  
19.         this.root = root;  
20.     }  
21.       
22.     //创建二叉树  
23.     public void buildTree() {  
24.           
25.         Scanner scn = null;  
26.         try {  
27.             scn = new Scanner(new File("input.txt"));  
28.         } catch (FileNotFoundException e) {  
29.             // TODO Auto-generated catch block  
30.             e.printStackTrace();  
31.         }  
32.         root = createTree(root,scn);          
33.     }  
34.     //先序遍历创建二叉树  
35.     private Node<T> createTree(Node<T> node,Scanner scn) {  
36.           
37.         String temp  = scn.next();  
38.           
39.         if (temp.trim().equals("#")) {  
40.             return null;  
41.         } else {  
42.             node = new Node<T>((T)temp);  
43.             node.setLeft(createTree(node.getLeft(), scn));  
44.             node.setRight(createTree(node.getRight(), scn));  
45.             return node;  
46.         }  
47.               
48.     }  
49.       
50.       
51.       
52.     //中序遍历(递归)  
53.     public void inOrderTraverse() {  
54.         inOrderTraverse(root);  
55.     }  
56.       
57.     public void inOrderTraverse(Node<T> node) {  
58.         if (node != null) {  
59.             inOrderTraverse(node.getLeft());  
60.             System.out.println(node.getValue());  
61.             inOrderTraverse(node.getRight());  
62.         }  
63.     }  
64.       
65.       
66.     //中序遍历(非递归)  
67.     public void nrInOrderTraverse() {  
68.           
69.         Stack<Node<T>> stack = new Stack<Node<T>>();  
70.         Node<T> node = root;  
71.         while (node != null || !stack.isEmpty()) {  
72.             while (node != null) {  
73.                 stack.push(node);  
74.                 node = node.getLeft();  
75.             }  
76.             node = stack.pop();  
77.             System.out.println(node.getValue());  
78.             node = node.getRight();  
79.               
80.         }  
81.                   
82.     }  
83.     //先序遍历(递归)  
84.     public void preOrderTraverse() {  
85.         preOrderTraverse(root);  
86.     }  
87.       
88.     public void preOrderTraverse(Node<T> node) {  
89.         if (node != null) {  
90.             System.out.println(node.getValue());  
91.             preOrderTraverse(node.getLeft());  
92.             preOrderTraverse(node.getRight());  
93.         }  
94.     }  
95.       
96.       
97.     //先序遍历（非递归）  
98.     public void nrPreOrderTraverse() {  
99.           
100.         Stack<Node<T>> stack = new Stack<Node<T>>();  
101.         Node<T> node = root;  
102.           
103.         while (node != null || !stack.isEmpty()) {  
104.               
105.             while (node != null) {  
106.                 System.out.println(node.getValue());  
107.                 stack.push(node);  
108.                 node = node.getLeft();  
109.             }  
110.             node = stack.pop();  
111.             node = node.getRight();  
112.         }  
113.                   
114.     }  
115.       
116.     //后序遍历(递归)  
117.     public void postOrderTraverse() {  
118.         postOrderTraverse(root);  
119.     }  
120.       
121.     public void postOrderTraverse(Node<T> node) {  
122.         if (node != null) {  
123.             postOrderTraverse(node.getLeft());  
124.             postOrderTraverse(node.getRight());  
125.             System.out.println(node.getValue());  
126.         }  
127.     }  
128.       
129.     //后续遍历(非递归)  
130.     public void nrPostOrderTraverse() {  
131.           
132.         Stack<Node<T>> stack = new Stack<Node<T>>();  
133.         Node<T> node = root;  
134.         Node<T> preNode = null;//表示最近一次访问的节点  
135.           
136.         while (node != null || !stack.isEmpty()) {  
137.               
138.             while (node != null) {  
139.                 stack.push(node);  
140.                 node = node.getLeft();  
141.             }  
142.               
143.             node = stack.peek();  
144.               
145.             if (node.getRight() == null || node.getRight() == preNode) {  
146.                 System.out.println(node.getValue());  
147.                 node = stack.pop();  
148.                 preNode = node;  
149.                 node = null;  
150.             } else {  
151.                 node = node.getRight();  
152.             }  
153.               
154.         }  
155.           
156.           
157.           
158.           
159.     }  
160.       
161.     //按层次遍历  
162.     public void levelTraverse() {  
163.         levelTraverse(root);  
164.     }  
165.       
166.     public void levelTraverse(Node<T> node) {  
167.       
168.         Queue<Node<T>> queue = new LinkedBlockingQueue<Node<T>>();  
169.         queue.add(node);  
170.         while (!queue.isEmpty()) {  
171.               
172.             Node<T> temp = queue.poll();  
173.             if (temp != null) {  
174.                 System.out.println(temp.getValue());  
175.                 queue.add(temp.getLeft());  
176.                 queue.add(temp.getRight());  
177.             }  
178.                           
179.         }  
180.                   
181.     }  
182.       
183.       
184.       
185.       
186. }  
187.   
188.   
189.   
190. //树的节点  
191.   
192. class Node<T> {  
193.       
194.     private Node<T> left;  
195.     private Node<T> right;  
196.     private T value;  
197.       
198.     public Node() {  
199.     }  
200.     public Node(Node<T> left,Node<T> right,T value) {  
201.         this.left = left;  
202.         this.right = right;  
203.         this.value = value;  
204.     }  
205.       
206.     public Node(T value) {  
207.         this(null,null,value);  
208.     }  
209.     public Node<T> getLeft() {  
210.         return left;  
211.     }  
212.     public void setLeft(Node<T> left) {  
213.         this.left = left;  
214.     }  
215.     public Node<T> getRight() {  
216.         return right;  
217.     }  
218.     public void setRight(Node<T> right) {  
219.         this.right = right;  
220.     }  
221.     public T getValue() {  
222.         return value;  
223.     }  
224.     public void setValue(T value) {  
225.         this.value = value;  
226.     }  
227.           
228. }  

测试代码：

[java]  view plain copy

1. package com.algorithm.tree;  
2.   
3. public class TreeTest {  
4.   
5.     /** 
6.      * @param args 
7.      */  
8.     public static void main(String[] args) {  
9.         Tree<Integer> tree = new Tree<Integer>();  
10.         tree.buildTree();  
11.         System.out.println("中序遍历");  
12.         tree.inOrderTraverse();  
13.         tree.nrInOrderTraverse();  
14.         System.out.println("后续遍历");  
15.         //tree.nrPostOrderTraverse();  
16.         tree.postOrderTraverse();  
17.         tree.nrPostOrderTraverse();  
18.         System.out.println("先序遍历");  
19.         tree.preOrderTraverse();  
20.         tree.nrPreOrderTraverse();  
21.           
22. //  
23.     }  
24.   
25. }