转载于 http://www.cnblogs.com/miloyip/archive/2010/05/12/binary_tree_traversal.html
问题定义
给定一棵二叉树,要求按分层遍历该二叉树,即从上到下按层次访问该二叉树(每一层将单独输出一行),每一层要求访问的顺序为从左到右,并将节点依次编号。下面是一个例子:
输出:
1 2 3 4 5 6 7 8
节点的定义:
1
2
3
4
5
|
struct
Node {
Node *pLeft;
Node *pRight;
int
data;
};
|
书上的解法
书上举出两个解法。第一个解法是用递归方式,搜寻并打印某一层的节点,再打印下一层的节点。这方法简单但时间效率不高(但不需要额外空间),因此书中亦提供了第二个解法。
书中第二个解法,使用vector容器来储存n个节点信息,并用一个游标变量last记录前一层的访问结束条件,实现如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
void
PrintNodeByLevel(Node* root) {
vector<Node*> vec;
// 这里我们使用STL 中的vector来代替数组,可利用到其动态扩展的属性
vec.push_back(root);
int
cur = 0;
int
last = 1;
while
(cur < vec.size()) {
Last = vec.size();
// 新的一行访问开始,重新定位last于当前行最后一个节点的下一个位置
while
(cur < last) {
cout << vec[cur] -> data <<
" "
;
// 访问节点
if
(vec[cur] -> lChild)
// 当前访问节点的左节点不为空则压入
vec.push_back(vec[cur] -> lChild);
if
(vec[cur] -> rChild)
// 当前访问节点的右节点不为空则压入,注意左右节点的访问顺序不能颠倒
vec.push_back(vec[cur] -> rChild);
cur++;
}
cout << endl;
// 当cur == last时,说明该层访问结束,输出换行符
}
}
|
广度优先搜索
书中没有提及,本问题其实是以广度优先搜索(breath-first search, BFS)去遍历一个树结构。广度优先搜索的典型实现是使用队列(queue)。其伪代码如下:
1
2
3
4
5
6
7
|
enqueue(Q, root)
do
node = dequeue(Q)
process(node)
//如把内容列印
for
each child of node
enqueue(Q, child)
while
Q is not empty
|
书上的解法,事实上也使用了一个队列。但本人认为,使用vector容器,较不直觉,而且其空间复杂度是O(n)。
如果用队列去实现BFS,不处理换行,能简单翻译伪代码为C++代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
void
PrintBFS(Node* root) {
queue<Node*> Q;
Q.push(root);
do
{
Node *node = Q.front();
Q.pop();
cout << node->data <<
" "
;
if
(node->pLeft)
Q.push(node->pLeft);
if
(node->pRight)
Q.push(node->pRight);
}
while
(!Q.empty());
}
|
本人觉得这样的算法实现可能比较清楚,而且空间复杂度只需O(m),m为树中最多节点的层的节点数量。最坏的情况是当二叉树为完整,m = n/2。
之后的难点在于如何换行。
本人的尝试之一
第一个尝试,利用了两个队列,一个储存本层的节点,另一个储存下层的节点。遍历本层的节点,把其子代节点排入下层队列。本层遍历完毕后,就可换行,并交换两个队列。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
void
PrintNodeByLevel(Node* root) {
deque<Node*> Q1, Q2;
Q1.push_back(root);
do
{
do
{
Node* node = Q1.front();
Q1.pop_front();
cout << node->data <<
" "
;
if
(node->pLeft)
Q2.push_back(node->pLeft);
if
(node->pRight)
Q2.push_back(node->pRight);
}
while
(!Q1.empty());
cout << endl;
Q1.swap(Q2);
}
while
(!Q1.empty());
}
|
本实现使用deque而不是queue,因为deque才支持swap()操作。注意,swap()是O(1)的操作,实际上只是交换指针。
这实现要用两个循环(书上的实现也是),并且用了两个队列。能够只用一个循环、一个队列么?
本人的尝试之二
换行问题其实在于如何表达一层的结束。书上采用了游标,而第一个尝试则用了两个队列。本人想到第三个可行方案,是把一个结束信号放进队列里。由于使用queue<Node*>,可以插入一个空指针去表示一层的遍历结束。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
void
PrintNodeByLevel(Node* root) {
queue<Node*> Q;
Q.push(root);
Q.push(0);
do
{
Node* node = Q.front();
Q.pop();
if
(node) {
cout << node->data <<
" "
;
if
(node->pLeft)
Q.push(node->pLeft);
if
(node->pRight)
Q.push(node->pRight);
}
else
if
(!Q.empty()) {
Q.push(0);
cout << endl;
}
}
while
(!Q.empty());
}
|
这个实现的代码很贴近之前的PrintBFS(),也只有一个循环。注意一点,当发现空指针(结束信号)时,要检查队列内是否还有节点,如果没有的话还插入新的结束信号,则会做成死循环。
测试代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
void
Link(Node* nodes,
int
parent,
int
left,
int
right) {
if
(left != -1)
nodes[parent].pLeft = &nodes[left];
if
(right != -1)
nodes[parent].pRight = &nodes[right];
}
void
main()
{
Node test1[9] = { 0 };
for
(
int
i = 1; i < 9; i++)
test1[i].data = i;
Link(test1, 1, 2, 3);
Link(test1, 2, 4, 5);
Link(test1, 3, 6, -1);
Link(test1, 5, 7, 8);
PrintBFS(&test1[1]);
cout << endl << endl;
PrintNodeByLevel(&test1[1]);
cout << endl;
}
|
扩展问题一、二
扩展问题一、二是按深度从下到上遍历二叉树,从左向右或者从右向左。
我们可以在开始根节点遍历的时候,每层遍历结束之后,存放一个 NULL 作为层与层之间的分割,当整棵树遍历完之后,再从后向前遍历数组,遇到 NULL 表示当前层结束,这样就可以实现按深度从下到上的遍历。
算法的时间复杂度与按深度从上到下时间复杂度相同,空间多用了4*H Bytes ( H 为树的高度 )
#include <vector>
#include <iostream>
using namespace std;
struct node
{
node* left;
node* right;
int value;
node( int v ): value( v ),left(NULL),right(NULL) {};
};
vector<const node*> vec;
void steps( const node* root, bool fromLeftToRight ) //true: 从左往右遍历 //false: 从右往左遍历
{
int cur = 0;
int last;
vec.clear();
vec.push_back( root );
while ( cur < vec.size() )
{
last = vec.size();
vec.push_back( NULL ); //层与层之间的分割
while( cur < last )
{
if ( fromLeftToRight )
{
if ( vec[cur]->right )
vec.push_back(vec[cur]->right);
if ( vec[cur]->left )
vec.push_back( vec[cur]->left);
}
else
{
if ( vec[cur]->left )
vec.push_back( vec[cur]->left );
if ( vec[cur]->right )
vec.push_back( vec[cur]->right );
}
cur++;
}
cur += 1 ; //跳过层与层之间的NULL节点
}
//反向遍历数组
vector<const node*>::const_reverse_iterator cri;
for( cri = vec.rbegin() + 1; cri != vec.rend(); cri++ )
{
if ( !*cri )
{
cout << endl;
}
else
{
cout << (*cri)->value << " " ;
}
}
cout << endl;
}
书中的 test case:
int main()
{
node* root = new node(1);
node* tmp = new node(2);
root->left = tmp;
tmp = new node(3);
root->right = tmp;
tmp = new node(4);
root->left->left = tmp;
tmp = new node(5);
root->left->right = tmp;
tmp = new node(6);
root->right->right = tmp;
tmp = new node(7);
root->left->right->left = tmp;
tmp = new node(8);
root->left->right->right = tmp;
cout << "From Left To the Right " << endl;
steps(root,true);
cout << "From Right To the Left " << endl;
steps(root,false);
return 0;
}