《编程之美：分层遍历二叉树》的另外两个实现

转载于 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; }

 

扩展问题一、二

 转自 : http://hi.baidu.com/azuryy/item/d108414bbf982a0a6dc2f0d7

书中解法三用数组来对树进行BFS，比较适合在比赛中使用，如果使用队列的话，当数据规模比较大的时候，频繁的进队列，出队列还是很耗时的。 比较经典的“聪明的打字员”一题，就是BFS搜索，但是数据规模比较大，用队列的话很容易超时，参考PKU1184.

扩展问题一、二是按深度从下到上遍历二叉树，从左向右或者从右向左。
我们可以在开始根节点遍历的时候，每层遍历结束之后，存放一个 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;
}