输入一颗二元树，从上向下按层打印树的每个节点，同一层中，按照从左到右的顺序打印。

输入一颗二元树，从上往下按层打印树的每个结点，同一层中按照从左往右的顺序打印，具体实现如下：

[cpp]  view plain copy

1. #include <iostream>  
2. using namespace std;  
3.   
4. typedef struct BSTNode  
5. {  
6.     int nValue;  
7.     struct BSTNode *pLChild;  
8.     struct BSTNode *pRChild;  
9. }*PBSTree;  
10.   
11.   
12. PBSTree Insert(PBSTree pRoot, int value)  
13. {  
14.     if (pRoot == NULL)  
15.     {  
16.         pRoot = new BSTNode;  
17.         pRoot->nValue = value;  
18.         pRoot->pLChild = NULL;  
19.         pRoot->pRChild = NULL;  
20.     }  
21.     else  
22.     {  
23.         if (value < pRoot->nValue)  
24.         {  
25.             pRoot->pLChild = Insert(pRoot->pLChild, value);  
26.         }  
27.         else if (value > pRoot->nValue)  
28.         {  
29.             pRoot->pRChild = Insert(pRoot->pRChild, value);  
30.         }  
31.     }  
32.     return pRoot;  
33. }  
34.   
35. //非递归实现插入  
36. void Insert1(PBSTree *pRoot, int value)  
37. {  
38.     if ((*pRoot) == NULL)  
39.     {  
40.         (*pRoot) = new BSTNode;  
41.         (*pRoot)->nValue = value;  
42.         (*pRoot)->pLChild = NULL;  
43.         (*pRoot)->pRChild = NULL;  
44.     }  
45.     else  
46.     {  
47.         PBSTree pCur = (*pRoot);  
48.         while (1)  
49.         {  
50.             if (value == pCur->nValue)  
51.             {  
52.                 return;  
53.             }  
54.             else if (value < pCur->nValue)  
55.             {  
56.                 if (pCur->pLChild == NULL)  
57.                 {  
58.                     PBSTree pTmp = new BSTNode;  
59.                     pTmp->nValue = value;  
60.                     pTmp->pLChild = pTmp->pRChild = NULL;  
61.                     pCur->pLChild = pTmp;  
62.   
63.                     return;  
64.                 }  
65.                 else  
66.                 {  
67.                     pCur = pCur->pLChild;  
68.                 }  
69.   
70.             }  
71.             else  
72.             {  
73.                 if (pCur->pRChild == NULL)  
74.                 {  
75.                     PBSTree pTmp = new BSTNode;  
76.                     pTmp->nValue = value;  
77.                     pTmp->pLChild = pTmp->pRChild = NULL;  
78.                     pCur->pRChild = pTmp;  
79.   
80.                     return;  
81.                 }  
82.                 else  
83.                 {  
84.                     pCur = pCur->pRChild;  
85.                 }  
86.             }  
87.         }  
88.     }  
89. }  
90.   
91. void Visit(PBSTree pRoot)  
92. {  
93.     cout << pRoot->nValue << " ";  
94. }  
95.   
96. //该树转换为它的镜像    递归实现  
97. PBSTree Change(PBSTree pRoot)  
98. {  
99.     if (pRoot->pLChild == NULL && pRoot->pRChild == NULL)  
100.     {  
101.         return NULL;  
102.     }  
103.     else  
104.     {  
105.         PBSTree pTmp = pRoot->pLChild;  
106.         pRoot->pLChild = pRoot->pRChild;  
107.         pRoot->pRChild = pTmp;  
108.         Change(pRoot->pLChild);  
109.         Change(pRoot->pRChild);  
110.   
111.   
112.     }  
113.   
114.     return pRoot;  
115. }  
116.   
117. //该树转换为它的镜像    非递归实现  
118. void Change1(PBSTree *pRoot)  
119. {  
120.     PBSTree stack[100];  
121.     int nTop = 0;  
122.     PBSTree pCur = *pRoot;  
123.     while (nTop > 0 || pCur != NULL)  
124.     {  
125.         while (pCur != NULL)  
126.         {  
127.             PBSTree pTmp = pCur->pLChild;  
128.             pCur->pLChild = pCur->pRChild;  
129.             pCur->pRChild = pTmp;  
130.             stack[nTop++] = pCur;  
131.             pCur = pCur->pLChild;  
132.         }  
133.   
134.         if (nTop > 0)  
135.         {  
136.             nTop--;  
137.             pCur = stack[nTop];  
138.             pCur = pCur->pRChild;  
139.         }  
140.     }  
141. }  
142.   
143.   
144.   
145. //前序递归实现  
146. void PreOrder(PBSTree pRoot)  
147. {  
148.     if (pRoot == NULL)  
149.     {  
150.         return;  
151.     }  
152.     Visit(pRoot);  
153.     PreOrder(pRoot->pLChild);  
154.     PreOrder(pRoot->pRChild);  
155. }  
156.   
157. void PreOrder1(PBSTree pRoot)  
158. {  
159.     PBSTree stack[100];  
160.     int nTop = 0;  
161.     PBSTree pCur = pRoot;  
162.     while (nTop > 0 || pCur != NULL)  
163.     {  
164.         while (pCur != NULL)  
165.         {  
166.             Visit(pCur);  
167.             stack[nTop++] = pCur;  
168.             pCur = pCur->pLChild;  
169.         }  
170.   
171.   
172.         if (nTop > 0)  
173.         {  
174.             nTop--;  
175.             pCur = stack[nTop];  
176.             pCur = pCur->pRChild;  
177.         }  
178.     }  
179. }  
180. //中序非递归实现  
181. void InOrder1(PBSTree pRoot)  
182. {  
183.     PBSTree stack[100];  
184.     int nTop = 0;  
185.     PBSTree pCur = pRoot;  
186.     while (nTop > 0 || pCur != NULL)  
187.     {  
188.         while (pCur != NULL)  
189.         {  
190.   
191.             stack[nTop++] = pCur;  
192.             pCur = pCur->pLChild;  
193.         }  
194.         if (nTop > 0)  
195.         {  
196.             nTop--;  
197.             pCur = stack[nTop];  
198.             Visit(pCur);  
199.             pCur = pCur->pRChild;  
200.         }  
201.     }  
202. }  
203.   
204. //中序遍历 递归实现  
205. void InOrder(PBSTree pRoot)  
206. {  
207.     if (pRoot == NULL)  
208.     {  
209.         return;  
210.     }  
211.     InOrder(pRoot->pLChild);  
212.     Visit(pRoot);  
213.     InOrder(pRoot->pRChild);  
214. }  
215.   
216. //后序 递归实现  
217. void PostOrder(PBSTree pRoot)  
218. {  
219.     if (pRoot == NULL)  
220.     {  
221.         return;  
222.     }  
223.     PostOrder(pRoot->pLChild);  
224.     PostOrder(pRoot->pRChild);  
225.     Visit(pRoot);  
226. }  
227.   
228. //后序 非递归实现  
229. void PostOrder1(PBSTree pRoot)  
230. {  
231.   
232.     PBSTree stack[100];  
233.     int nTop = 0;  
234.     PBSTree pCur = pRoot;  
235.     PBSTree IsVisited = NULL;  
236.     while (nTop > 0 || pCur != NULL)  
237.     {  
238.         while (pCur != NULL)  
239.         {  
240.             stack[nTop++] = pCur;  
241.             pCur = pCur->pLChild;  
242.         }  
243.   
244.         pCur = stack[nTop - 1];  
245.         if (pCur->pRChild == NULL && IsVisited == pCur->pRChild)  
246.         {  
247.             Visit(pCur);  
248.             nTop--;  
249.             IsVisited = pCur;  
250.             pCur = NULL;  
251.         }  
252.         else  
253.         {  
254.             pCur = pCur->pRChild;  
255.         }  
256.     }  
257. }  
258.   
259. //水平遍历二叉搜索树  
260. void LevelOrder(PBSTree pRoot)  
261. {  
262.     PBSTree queue[100];  
263.     int nHead = 0;  
264.     int nTail = 0;  
265.   
266.     PBSTree pCur = pRoot;  
267.     if (pCur)  
268.     {  
269.         queue[nTail++] = pCur;  
270.         while (nHead != nTail)  
271.         {  
272.             PBSTree pTmp = queue[nHead++];  
273.             Visit(pTmp);  
274.             if (pTmp->pLChild)  
275.             {  
276.                 queue[nTail++] = pTmp->pLChild;  
277.             }  
278.             if (pTmp->pRChild)  
279.             {  
280.                 queue[nTail++] = pTmp->pRChild;  
281.             }  
282.         }  
283.     }  
284. }  
285. int main()  
286. {  
287.     PBSTree pRoot = NULL;  
288.     Insert1(&pRoot, 8);  
289.     Insert1(&pRoot, 6);  
290.     Insert1(&pRoot, 5);  
291.     Insert1(&pRoot, 7);  
292.     Insert1(&pRoot, 10);  
293.     Insert1(&pRoot, 9);  
294.     Insert1(&pRoot, 11);  
295.     LevelOrder(pRoot);  
296.     printf("\n");  
297.     system("pause");  
298.     return 0;  
299. }  

运行效果如图1所示：

图1 运行效果