一个用于实现初始化指定个数的完全二叉树，以及两个非递归的深度优先遍历，和广度优先遍历

1. package fifth;
2. import java.util.Random;
3. public class Tool{
4. public static Random rand= new Random();
5. }
6. -------------------------------------------------------------
7. package fifth;
8. import java.util.EmptyStackException;
9. import java.util.LinkedList;
10. import java.util.Queue;
11. import java.util.Stack;
12. public class Tree {
13. //用来实现非递归的广度优先查询与构造需要的队列
14. public static Queue<Tree> que= new LinkedList<Tree>();
15. //用来实现深度优先查询需要的栈
16. public static Stack<Tree> stack=new Stack<Tree>();
17. //存储的节点信息
18. public int data;
19. public Tree leftNode=null;
20. public Tree rightNode=null;
21. //用来实现遍历的临时节点
22. public Tree cTree=null;
23. public Tree() {
24. data=Tool.rand.nextInt(200);
25. display();
26. }
27. public void display(){
28. System.out.print(data+",");
29. }
30. /**
31. * 创建一个以这个节点为定点的完全二叉树
32. * 这个中初始化方法类似于广度优先遍历
33. * @param count 要创建的完全二叉树的节点个数
34. */
35. public void initTree(int count){
36. que.add(this);
37. while((cTree=que.poll())!=null)
38. {
39. //当树中需要创建节点数小于两个时,那么就应该创造完叶子节点然后返回
40. //当树中需要创建节点个数大于两个时，那么就应该把创造的子节点放入队列中，等待创建它的子节点
41. if(count-2>0)
42. {
43. cTree.leftNode=new Tree();
44. que.add(cTree.leftNode);
45. count--;
46. cTree.rightNode=new Tree();
47. que.add(cTree.rightNode);
48. count--;
49. }
50. else if(count==0)
51. {
52. break;
53. }
54. else if(count==1)
55. {
56. cTree.leftNode=new Tree();
57. count--;
58. break;
59. }
60. else
61. {
62. cTree.leftNode=new Tree();
63. cTree.rightNode=new Tree();
64. count-=2;
65. }
66. }
67. }
68. /**
69. * 非递归的广度优先遍历,用的队列来实现
70. */
71. public void breadthSearch(){
72. System.out.print('\n'+"非递归广度优先遍历:");
73. //清空队列，同时把自己放在队列的第一个元素
74. que.clear();que.add(this);
75. while((cTree=que.poll())!=null)
76. {
77. //访问队列中的数据
78. cTree.display();
79. if(cTree.leftNode!=null)
80. {
81. que.add(cTree.leftNode);
82. }
83. if(cTree.rightNode!=null)
84. {
85. que.add(cTree.rightNode);
86. }
87. }
88. }
89. /**
90. * 用于栈来实现的非递归深度优先遍历 前序遍历
91. */
92. public void deepFirstSearch(){
93. System.out.print('\n'+"非递归深度优先遍历,前序遍历:");
94. //首先把自己压入栈底
95. this.display();
96. cTree=this;
97. while(cTree!=null)
98. {
99. if(cTree.leftNode!=null)
100. {
101. stack.add(cTree);
102. cTree.leftNode.display();
103. cTree=cTree.leftNode;
104. }
105. else
106. {
107. while(cTree.rightNode==null)
108. {
109. try
110. {
111. cTree=stack.pop();
112. }
113. catch(EmptyStackException e)
114. {
115. return;
116. }
117. }
118. cTree.rightNode.display();
119. cTree=cTree.rightNode;
120. }
121. }
122. }
123. public static void main(String[] args) {
124. Tree tree= new Tree();
125. tree.initTree(10);
126. System.out.println();
127. tree.leftNode.display();
128. tree.rightNode.display();
129. tree.breadthSearch();
130. tree.deepFirstSearch();
131. }
132. }