二叉树层次遍历

给定一棵二叉树，要求进行分层遍历，每层的节点值单独打印一行，下图给出事例结构：

对此二叉树遍历的结果应该是：

1，

2 ， 3

4， 5， 6

7， 8

第一种方法，就是利用递归的方法，按层进行打印，我们把根节点当做第0层，之后层次依次增加，如果我们想打印第二层怎么办呢，利用递归的代码如下：

[cpp]  view plain copy

1. int print_at_level(Tree T, int level) {  
2.     if (!T || level < 0)  
3.         return 0;  
4.     if (0 == level) {  
5.         cout << T->data << " ";  
6.         return 1;  
7.     }  
8.     return print_at_level(T->lchild, level - 1) + print_at_level(T->rchild, level - 1);  
9. }  

如果我们成功的打印了给定的层次，那么就返回非0的正值，如果失败返回0。有了这个思路，我们就可以应用一个循环，来打印这颗树的所有层的节点，但是有个问题就是我们不知道这棵二叉树的深度，怎么来控制循环使其结束呢，仔细看一下print_at_level，如果指定的Tree是空的，那么就直接返回0，当返回0的时候，我们就结束循环，说明没有节点可以打印了。

[cpp]  view plain copy

1. void print_by_level_1(Tree T) {  
2.     int i = 0;   
3.     for (i = 0; ; i++) {  
4.         if (!print_at_level(T, i))  
5.             break;  
6.     }  
7.     cout << endl;  
8. }  

以上的方法可以很清楚的看出，存在重复访问的情况，就是第0层访问的次数最多，第1层次之。所以这个递归的方法不是很有效的方法。

第二种方法：我们可以设置两个队列，想象一下队列的特点，就是先进先出，首先把第0层保存在一个队列中，然后按节点访问，并把已经访问节点的左右孩子节点放在第二个队列中，当第一个队列中的所有节点都访问完成之后，交换两个节点。这样重复下去，知道所有层的节点都被访问，这样做的代价就是空间复杂度有点高。

[cpp]  view plain copy

1. void print_by_level_2(Tree T) {  
2.     deque<tree_node_t*> q_first, q_second;  
3.     q_first.push_back(T);  
4.     while(!q_first.empty()) {  
5.         while (!q_first.empty()) {  
6.             tree_node_t *temp = q_first.front();  
7.             q_first.pop_front();  
8.             cout << temp->data << " ";  
9.             if (temp->lchild)  
10.                 q_second.push_back(temp->lchild);  
11.             if (temp->rchild)  
12.                 q_second.push_back(temp->rchild);  
13.         }  
14.         cout << endl;  
15.         q_first.swap(q_second);  
16.     }  
17. }  

第三种方法就是设置双指针，一个指向访问当层开始的节点，一个指向访问当层结束节点的下一个位置：

这是第一层访问的情况，当访问第0层之后的结构如下，把第0层的所有子节点加入之后：

访问完第1层之后：

之后大家就可以自己画图了，下面给出程序代码：

[cpp]  view plain copy

1. void print_by_level_3(Tree T) {  
2.     vector<tree_node_t*> vec;  
3.     vec.push_back(T);  
4.     int cur = 0;  
5.     int end = 1;  
6.     while (cur < vec.size()) {  
7.         end = vec.size();  
8.         while (cur < end) {  
9.             cout << vec[cur]->data << " ";  
10.             if (vec[cur]->lchild)  
11.                 vec.push_back(vec[cur]->lchild);  
12.             if (vec[cur]->rchild)  
13.                 vec.push_back(vec[cur]->rchild);  
14.             cur++;  
15.         }  
16.         cout << endl;  
17.     }  
18. }  

最后给出完成代码的测试用例：124##57##8##3#6##

[cpp]  view plain copy

1. #include<iostream>  
2. #include<vector>  
3. #include<deque>  
4. using namespace std;  
5.   
6. typedef struct tree_node_s {  
7.     char data;  
8.     struct tree_node_s *lchild;  
9.     struct tree_node_s *rchild;  
10. }tree_node_t, *Tree;  
11.   
12. void create_tree(Tree *T) {  
13.     char c = getchar();  
14.     if (c == '#') {  
15.         *T = NULL;  
16.     } else {  
17.         *T = (tree_node_t*)malloc(sizeof(tree_node_t));  
18.         (*T)->data = c;  
19.         create_tree(&(*T)->lchild);  
20.         create_tree(&(*T)->rchild);  
21.     }  
22. }  
23.   
24. void print_tree(Tree T) {  
25.     if (T) {  
26.         cout << T->data << " ";  
27.         print_tree(T->lchild);  
28.         print_tree(T->rchild);  
29.     }  
30. }  
31. int print_at_level(Tree T, int level) {  
32.     if (!T || level < 0)  
33.         return 0;  
34.     if (0 == level) {  
35.         cout << T->data << " ";  
36.         return 1;  
37.     }  
38.     return print_at_level(T->lchild, level - 1) + print_at_level(T->rchild, level - 1);  
39. }  
40.   
41. void print_by_level_1(Tree T) {  
42.     int i = 0;   
43.     for (i = 0; ; i++) {  
44.         if (!print_at_level(T, i))  
45.             break;  
46.     }  
47.     cout << endl;  
48. }  
49.   
50. void print_by_level_2(Tree T) {  
51.     deque<tree_node_t*> q_first, q_second;  
52.     q_first.push_back(T);  
53.     while(!q_first.empty()) {  
54.         while (!q_first.empty()) {  
55.             tree_node_t *temp = q_first.front();  
56.             q_first.pop_front();  
57.             cout << temp->data << " ";  
58.             if (temp->lchild)  
59.                 q_second.push_back(temp->lchild);  
60.             if (temp->rchild)  
61.                 q_second.push_back(temp->rchild);  
62.         }  
63.         cout << endl;  
64.         q_first.swap(q_second);  
65.     }  
66. }  
67.   
68. void print_by_level_3(Tree T) {  
69.     vector<tree_node_t*> vec;  
70.     vec.push_back(T);  
71.     int cur = 0;  
72.     int end = 1;  
73.     while (cur < vec.size()) {  
74.         end = vec.size();  
75.         while (cur < end) {  
76.             cout << vec[cur]->data << " ";  
77.             if (vec[cur]->lchild)  
78.                 vec.push_back(vec[cur]->lchild);  
79.             if (vec[cur]->rchild)  
80.                 vec.push_back(vec[cur]->rchild);  
81.             cur++;  
82.         }  
83.         cout << endl;  
84.     }  
85. }  
86.   
87. int main(int argc, char *argv[]) {  
88.     Tree T = NULL;  
89.     create_tree(&T);  
90.     print_tree(T);  
91.     cout << endl;  
92.     print_by_level_3(T);  
93.     cin.get();  
94.     cin.get();  
95.     return 0;