二叉树遍历（Java实现）

二叉树遍历（Java实现）

 

主要是二叉树的遍历，包括递归遍历和非递归遍历

1. import java.util.ArrayDeque;
2. import java.util.ArrayList;
3. import java.util.List;
4. import java.util.Queue;
5. public class BinaryNode<T> {
6. /**
7. * 泛型BinaryNode类
8. */
9. public T item;
10. public BinaryNode<T> left,right;//左右子树
11. public BinaryNode(T item)
12. {
13. this.item = item;
14. left = right = null;
15. }
16. public BinaryNode (T item, BinaryNode<T> left, BinaryNode<T> right)
17. {
18. this.item = item;
19. this.left = left;
20. this.right = right;
21. }
22. public T getNodeValue() {
23. return item;
24. }
25. public void setNodeValue(T item) {
26. this.item = item;
27. }
28. public BinaryNode<T> getLeft() {
29. return left;
30. }
31. public void setLeft(BinaryNode<T> left) {
32. this.left = left;
33. }
34. public BinaryNode<T> getRight() {
35. return right;
36. }
37. public void setRight(BinaryNode<T> right) {
38. this.right = right;
39. }
40. //判断是否为叶子
41. public boolean isLeaf(){
42. return (left==null)&&(right==null);
43. }
44. //前序遍历二叉树(递归)
45. public List<BinaryNode<T>> toStringPreorder(BinaryNode<T> node){
46. List<BinaryNode<T>> list=new ArrayList<BinaryNode<T>>();
47. list.add(node);
48. if (node.left!=null) {
49. list.addAll(toStringPreorder(node.left));
50. }
51. if (node.right!=null) {
52. list.addAll(toStringPreorder(node.right));
53. }
54. return list;
55. }
56. //前序遍历二叉树(非递归)
57. public List<BinaryNode<T>> toStringPreorderNoRec(BinaryNode<T> node){
58. List<BinaryNode<T>> list=new ArrayList<BinaryNode<T>>();
59. ArrayDeque<BinaryNode<T>> stack=new ArrayDeque<BinaryNode<T>>();
60. while ((node!=null)||!stack.isEmpty()) {
61. if (node!=null) {
62. list.add(node);
63. stack.push(node);
64. node=node.left;
65. } else {
66. node=stack.peek();
67. stack.pop();
68. node=node.right;
69. }
70. }
71. return list;
72. }
73. //中序遍历二叉树
74. public List<BinaryNode<T>> toStringInorder(BinaryNode<T> node){
75. List<BinaryNode<T>> list=new ArrayList<BinaryNode<T>>();
76. if (node.left!=null) {
77. list.addAll(toStringPreorder(node.left));
78. }
79. list.add(node);
80. if (node.right!=null) {
81. list.addAll(toStringPreorder(node.right));
82. }
83. return list;
84. }
85. //中序遍历二叉树(非递归)
86. public List<BinaryNode<T>> toStringInorderNoRec(BinaryNode<T> node){
87. List<BinaryNode<T>> list=new ArrayList<BinaryNode<T>>();
88. ArrayDeque<BinaryNode<T>> stack=new ArrayDeque<BinaryNode<T>>();
89. while ((node!=null)||!stack.isEmpty()) {
90. if (node!=null) {
91. stack.push(node);
92. node=node.left;
93. } else {
94. node=stack.peek();
95. list.add(node);
96. stack.pop();
97. node=node.right;
98. }
99. }
100. return list;
101. }
102. //后序遍历二叉树
103. public String toStringPostorder(){
104. String result="";
105. if (left!=null) {
106. result += left.toStringPostorder();
107. }
108. if (right!=null) {
109. result += right.toStringPostorder();
110. }
111. result += item;
112. return result;
113. }
114. //后序遍历二叉树(非递归)
115. /**
116. * 先遍历树的逆后序遍历(根、右、左),在翻转逆后序遍历就是后序遍历二叉树(左、右、根)
117. * @return result栈
118. */
119. public ArrayDeque<BinaryNode<T>> toStringPostorderNoRec(BinaryNode<T> node){
120. ArrayDeque<BinaryNode<T>> stack=new ArrayDeque<BinaryNode<T>>();
121. ArrayDeque<BinaryNode<T>> result=new ArrayDeque<BinaryNode<T>>();
122. while ((node!=null)||!stack.isEmpty()) {
123. if (node!=null) {
124. result.push(node);
125. stack.push(node);
126. node=node.right;
127. } else {
128. node=stack.peek();
129. stack.pop();
130. node=node.left;
131. }
132. }
133. return result;
134. }
135. //后序遍历二叉树2(非递归)
136. /**
137. * 要保证根结点在左孩子和右孩子访问之后才能访问，因此对于任一结点P，先将其入栈。如果P不存在左孩子和右孩子，则可以直接访问它；
138. * 或者P存在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了，则同样可以直接访问该结点。若非上述两种情况，
139. * 则将P的右孩子和左孩子依次入栈，这样就保证了每次取栈顶元素的时候，左孩子在右孩子前面被访问，左孩子和右孩子都在根结点前面被访问。
140. * @return result栈
141. */
142. public ArrayList<BinaryNode<T>> toStringPostorderNoRec2(BinaryNode<T> root){
143. ArrayDeque<BinaryNode<T>> stack=new ArrayDeque<BinaryNode<T>>();
144. ArrayList<BinaryNode<T>> result=new ArrayList<BinaryNode<T>>();
145. BinaryNode<T> curr;//当前栈顶指针
146. BinaryNode<T> pre=null;//前一次访问节点
147. stack.push(root);
148. while (!stack.isEmpty()) {
149. curr=stack.peek();
150. if ((curr.left==null&&curr.right==null)||(pre!=null&&(pre==curr.left||pre==curr.right))) {
151. result.add(curr);//输出结果
152. stack.pop();
153. pre=curr;
154. } else {
155. if (curr.right!=null) {
156. stack.push(curr.right);
157. }
158. if (curr.left!=null) {
159. stack.push(curr.left);
160. }
161. }
162. }
163. return result;
164. }
165. //层序遍历(广度优先遍历)
166. public List<BinaryNode<T>> toStringLevelOrder(){
167. List<BinaryNode<T>> list=new ArrayList<BinaryNode<T>>();
168. Queue<BinaryNode<T>> queue=new ArrayDeque<BinaryNode<T>>();
169. queue.offer(this);//root
170. while (!(queue.isEmpty())) {
171. list.add(queue.peek());
172. BinaryNode<T> node=queue.poll();
173. if (node.left != null) {
174. queue.offer(node.left);
175. }
176. if (node.right != null) {
177. queue.offer(node.right);
178. }
179. }
180. return list;
181. }
182. }