Java实现二叉树的创建、递归/非递归遍历

最近复习数据结构中的二叉树的相关问题，在这里整理一下

这里包括：
1、二叉树的先序创建

2、二叉树的递归先序遍历

3、二叉树的非递归先序遍历

4、二叉树的递归中序遍历

5、二叉树的非递归中序遍历

6、二叉树的递归后序遍历

7、二叉树的非递归后序遍历

8、二叉树的层次遍历

 

 

 

[java]  view plain copy

 

1. /**二叉树的结点定义*/  
2. class Node<T>{  
3.     private T value;  
4.     private Node<T> left;  
5.     private Node<T> right;  
6.       
7.     public Node(){  
8.     }  
9.     public Node(Node<T> left, Node<T> right, T value){  
10.         this.left = left;  
11.         this.right = right;  
12.         this.value = value;  
13.     }  
14.     public Node(T value){  
15.         this(null, null, value);  
16.     }  
17.       
18.     public Node<T> getLeft(){  
19.         return this.left;  
20.     }  
21.     public void setLeft(Node<T> left){  
22.         this.left = left;  
23.     }  
24.     public Node<T> getRight(){  
25.         return this.right;  
26.     }  
27.     public void setRight(Node<T> right){  
28.         this.right = right;  
29.     }  
30.     public T getValue(){  
31.         return this.value;  
32.     }  
33.     public void setValue(T value){  
34.         this.value = value;  
35.     }  
36. }  

 

 

[java]  view plain copy

 

1. import java.io.File;  
2. import java.io.FileNotFoundException;  
3. import java.util.LinkedList;  
4. import java.util.Scanner;  
5.   
6. /** 
7.  * 二叉树的定义：或为空，或只有根节点，或有左子树和右子树（5种基本形态） 
8.  * 二叉树性质： 
9.  * 1、在二叉树的第i层上至多有2^(i-1)个结点（i>=1） 
10.  * 2、深度为k的二叉树至多有2^(k) - 1个结点（k>=1） 
11.  * 3、对于任何一颗二叉树，如果其终端结点数为n，度数为2的结点数为m，则n = m + 1 
12.  * 4、具有n个结点的完全二叉树的深度为k = floor(log2(n)) + 1 
13.  * 5、在含有n个结点的二叉链表中有n+1个空链域 
14.  *  
15.  * @author 小菜鸟 
16.  *创建时间：2014-08-10 
17.  */  
18.   
19. public class BinaryTree<T> {  
20.   
21.     /**二叉树的根节点*/  
22.     private Node<T> root;  
23.       
24.     public BinaryTree(){}  
25.     public BinaryTree(Node<T> root){  
26.         this.root = root;  
27.     }  
28.       
29.     /**先序遍历创建二叉树*/  
30.     /**input.txt: - + a # # * # # / e # # f # # 
31.      * # 代表空结点 
32.      */  
33.     public void createBiTree(){  
34.         Scanner scn = null;  
35.           
36.         try {  
37.             scn = new Scanner(new File("input.txt"));  
38.         } catch (FileNotFoundException e) {  
39.             e.printStackTrace();  
40.         }  
41.           
42.         this.root = createBiTree(root, scn);  
43.     }  
44.     private Node<T> createBiTree(Node<T> node, Scanner scn) {  
45.           
46.         String temp = scn.next();  
47.         if(temp.trim().equals("#")){  
48.             return null;  
49.         }  
50.         else{  
51.             node = new Node<T>((T)temp);  
52.             node.setLeft(createBiTree(node.getLeft(), scn));  
53.             node.setRight(createBiTree(node.getRight(), scn));  
54.             return node;  
55.         }  
56.     }  
57.       
58.     /**先序递归遍历二叉树*/  
59.     public void preOrderTraverse(){  
60.         preOrderTraverse(root);  
61.     }  
62.     private void preOrderTraverse(Node<T> node) {  
63.         if(node != null){  
64.             System.out.println(node.getValue());  
65.             preOrderTraverse(node.getLeft());  
66.             preOrderTraverse(node.getRight());  
67.         }  
68.     }  
69.       
70.       
71.     /**先序非递归遍历二叉树*/  
72.     public void nrPreOrderTraverse(){  
73.         Stack<Node<T>> stack = new Stack<Node<T>>();  
74.         Node<T> node = root;  
75.         while(node != null || !stack.isEmpty()){  
76.             while(node != null){  
77.                 System.out.println(node.getValue());  
78.                 stack.push(node);  
79.                 node = node.getLeft();  
80.             }  
81.             node = stack.pop();  
82.             node = node.getRight();  
83.         }  
84.     }  
85.       
86.       
87.       
88.     /**中序递归遍历二叉树*/  
89.     public void inOrderTraverse(){  
90.         inOrderTraverse(root);  
91.     }  
92.     private void inOrderTraverse(Node<T> node) {  
93.         if(node != null){  
94.             inOrderTraverse(node.getLeft());  
95.             System.out.println(node.getValue());  
96.             inOrderTraverse(node.getRight());  
97.         }  
98.     }  
99.       
100.     /**中序非递归遍历二叉树*/  
101.     public void nrInOrderTraverse(){  
102.         Stack<Node<T>> stack = new Stack<Node<T>>();  
103.         Node<T> node = root;  
104.         while(node != null || !stack.isEmpty()){  
105.             while(node != null){  
106.                 stack.push(node);  
107.                 node = node.getLeft();  
108.             }  
109.             node = stack.pop();  
110.             System.out.println(node.getValue());  
111.             node = node.getRight();  
112.         }  
113.     }  
114.       
115.     /**后序递归遍历二叉树*/  
116.     public void postOrderTraverse(){  
117.         postOrderTraverse(root);  
118.     }  
119.     private void postOrderTraverse(Node<T> node) {  
120.         if(node != null){  
121.             postOrderTraverse(node.getLeft());  
122.             postOrderTraverse(node.getRight());  
123.             System.out.println(node.getValue());  
124.         }  
125.     }  
126.       
127.     /**后序非递归遍历二叉树*/  
128.     public void nrPostOrderTraverse(){  
129.         Stack<Node<T>> stack = new Stack<Node<T>>();  
130.         Node<T> node = root;  
131.         Node<T> preNode = null;   //记录之前遍历的右结点  
132.         while(node != null || !stack.isEmpty()){  
133.             while(node != null){  
134.                 stack.push(node);  
135.                 node = node.getLeft();  
136.             }  
137.             node = stack.getTop();  
138.               
139.             /**如果右结点为空，或者右结点之前遍历过，打印根结点*/  
140.             if(node.getRight() == null || node.getRight() == preNode){  
141.                 System.out.println(node.getValue());  
142.                 node = stack.pop();  
143.                 preNode = node;  
144.                 node = null;  
145.             }  
146.             else{  
147.                 node = node.getRight();  
148.             }  
149.         }  
150.     }  
151.       
152.       
153.     /**层次遍历二叉树*/  
154.     public void levelTraverse(){  
155.         levelTraverse(root);  
156.     }  
157.     private void levelTraverse(Node<T> node) {  
158.         Queue<Node<T>> queue = new Queue<Node<T>>();  
159.         queue.push(node);  
160.         while(!queue.isEmpty()){  
161.             node = queue.pop();  
162.             if(node != null){  
163.                 System.out.println(node.getValue());  
164.                 queue.push(node.getLeft());  
165.                 queue.push(node.getRight());  
166.             }  
167.         }  
168.     }  
169.       
170.       
171.     public static void main(String[] args){  
172.         BinaryTree<String> bt = new BinaryTree<String>();  
173.         bt.createBiTree();  
174.         //bt.preOrderTraverse();  
175.         //bt.inOrderTraverse();  
176.         //bt.postOrderTraverse();  
177.         //bt.nrPreOrderTraverse();  
178.         //bt.nrInOrderTraverse();  
179.         //bt.nrPostOrderTraverse();  
180.         bt.levelTraverse();  
181.     }  
182. }