问题1：给定一颗二叉树，要求按分层遍历该二叉树，即从上到下按层访问该二叉树（每一层将单独输出一行），每一层要求访问的顺序为从左到右，并将节点依次编号，那么分层变量如图的二叉树：输出应为：
输出：
1 2 3 4 5 6 7 8
问题2：写另外一个函数，打印二叉树中某层次的节点（从左到右），其中根节点为第0层，函数原型为
int printNodeAtLevel(Node* root,int level)，成功返回0，失败返回0.
仔细看2个问题，我们发现解决了第二个问题，第一个问题也迎刃而解，
要想打印第k层，我们只需要打印k-1层的孩子即可。依此递减。
typedef struct Node{ Node* left; Node* right; char data; Node(char c) { data=c; left=NULL;//很重要 right=NULL; } ~Node() { delete left;//如果left为null，也没问题，delete兼容null delete right; } }*BiTree; typedef char ElemType; void createBiTree(BiTree& T) { ElemType elem; cin>>elem; if(elem!='#') { T=new Node(elem); createBiTree(T->left); createBiTree(T->right); } else T=NULL; } //输出以root为根节点的第level（从0开始）的所有节点，从左到右 int printNodeAtLevel(Node * root,int level) { if(!root) return 0; if(level==0) { cout<<root->data<<ends; return 1; } return printNodeAtLevel(root->left,level-1)+printNodeAtLevel(root->right,level-1); } int main() { BiTree T; createBiTree(T); cout<<printNodeAtLevel(T,2);//输出3 cout<<printNodeAtLevel(T,1);//输出2 }
输入:124##57##8##3#6##
上面的是个二路递归，递归效率较低。
如果改成:
if(level<0) return 0;
if(level==0)
运行有问题。
解决了问题2，如何解决问题1？
如果我们知道了二叉树深度为n，只需n次调用printNodeAtLevel就可以了。
void printNodeByLevle(Node* root,int depth)
{
for(int level=0;level<depth;level++)
{
printNodeAtLevel(root,level);
cout<<endl;
}
}
如何事先不知道，当访问二叉树某一层次失败的时候返回就可以了。如下：
void printNodeByLevle(Node* root)
{
for(int level=0; ;level++)
{
if(!printNodeAtLevel(root,level)
break;
cout<<endl;
}
}
至此我们解决了题目中的两个问题，但细心的读者可能会发现，其实在问题1的算法中，对二叉树的每一层访问都需要重新从根节点开始，直到访问完所有的层次。这样的做法，效率实在不高，那么有没有更好的算法呢？
从根节点出发,依次将每层的节点从左到右压入一个数组,并用一个游标Cur记录当前访问的节点,另一个游标Last指示当前层次的最后一个节点的下一个位置,以Cur==Last作为当前层次访问结束的条件,在访问某一层的同时将该层的所有节点的子节点压入数组,在访问完某一层之后,检查是否还有新的层次可以访问,直到访问完所有的层次.
首先将根节点1压入数组，并将游标cur置为0，数组下标从0开始，游标Last置为1.
cur<last,说明此层（第一层）尚未被访问，隐藏，依次访问Cur到Last之间的所有节点。知道Cur==Last，说明该层以及访问完，此时数组中还有未被访问到的节点，则输出换行符，并将Last定位于新一行的末尾（即数组当前最后一个元素的下一位）。
继续依次往下访问其他层次的节点，直到访问完所有的层次。
void printNodeByLevel2(Node* root) { if(root==NULL) return ; 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]->left) vec.push_back(vec[cur]->left); if(vec[cur]->right) vec.push_back(vec[cur]->right); cur++; } cout<<endl;//当cur==last，说明该层访问结束 } }
广度优先搜索
书中没有提及，本问题其实是以广度优先搜索(breath-first search, BFS)去遍历一个树结构。广度优先搜索的典型实现是使用队列(queue)。其伪代码如下:
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++代码:
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。
之后的难点在于如何换行。
第一个尝试，利用了两个队列，一个储存本层的节点，另一个储存下层的节点。遍历本层的节点，把其子代节点排入下层队列。本层遍历完毕后，就可换行，并交换两个队列。
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()); }
View Code
本实现使用deque而不是queue，因为deque才支持swap()操作。注意，swap()是O(1)的操作，实际上只是交换指针。
这实现要用两个循环(书上的实现也是)，并且用了两个队列。能够只用一个循环、一个队列么?
本人的尝试之二
换行问题其实在于如何表达一层的结束。书上采用了游标，而第一个尝试则用了两个队列。本人想到第三个可行方案，是把一个结束信号放进队列里。由于使用queue<Node*>，可以插入一个空指针去表示一层的遍历结束。
void printNodeByLevel3(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->left) q.push(node->left); if(node->right) q.push(node->right); } else if(!q.empty()) //一定要是else if { q.push(0); cout<<endl; } }while(!q.empty()); }
上面的代码很巧妙，当node为0时，该层已经结束。但是有个问题，要检测是否还有节点。
这个实现的代码很贴近之前的PrintBFS()，也只有一个循环。注意一点，当发现空指针(结束信号)时，要检查队列内是否还有节点，如果没有的话还插入新的结束信号，则会做成死循环。
参考：
http://www.cnblogs.com/miloyip/archive/2010/05/12/binary_tree_traversal.html
扩展问题：如果要求按深度从下到上访问二叉树,每层的访问顺序仍然是从左向右,如果从右向左呢?
依然是按层遍历二叉树，只是要求从下往上访问，并且每一层中结点的访问顺序为从右向左
分析：只要层与层之间加入哑元素（NULL），然后逆序输出队列Q即可
第一步：给每一层之间添加哑元素NULL
void PrintNodeByLevel(Node *root)
{
int last;
Node *p;
if(!root) return ;
InitQueue();
EnQueue(root);
EnQueue(NULL);
while(front < rear - 1)
{
last = rear - 1;
while(front < last)
{
p = DeQueue();
if(p->lChild) EnQueue(p->lChild);
if(p->rChild) EnQueue(p->rChild);
}
EnQueue(NULL);
front = last + 1;
}
}
第二步：逆序输出队列Q
for(int i = rear - 2 ; i >= 0 ; i--)
{
if(Q[i] == NULL)
printf("\n");
else
printf("%c", Q[i]->chValue);
}
百度一道面试题
输出二叉树第 m 层的第 k 个节点值(m, k 均从 0 开始计数)
先看百度笔试的这道原题
2．给定以下二叉树:
struct node_t
{
node_t *left, *right;
int value;
};
要求编写函数 node_t* foo(node_t *node, unsigned int m, unsigned int k);
输出以 node 为根的二叉树第 m 层的第 k 个节点值.
(level, k 均从 0 开始计数)
注意：
1） 此树不是完全二叉树；
2） 所谓的第K个节点，是本层中从左到右的第K个节点
不合要求的做法：递归，利用||从左往右的计算顺序以及其真值关系
int printMK(Node* root,int m,int k,int *cnt) { if(!root || m<0) return 0; if(m==0) { if(*cnt==k) { cout<<root->data<<endl; return 1; } *cnt+=1; return 0; } return printMK(root->left,m-1,k,cnt) || printMK(root->right,m-1,k,cnt); }
int *cnt=new int(0);
printMK(T,2,1,cnt);
解法：
void printMK2(BiTree T,int m,int k) { int num=0; int level=0; queue<Node*> q; q.push(T); q.push(0); do{ Node* node=q.front(); q.pop(); if(node) { num++; if(level==m&& num-1==k) { cout<<node->data<<" "; break;} if(node->left) q.push(node->left); if(node->right) q.push(node->right); } else if(!q.empty()) { level++; num=0; q.push(0); cout<<endl; } }while(!q.empty()); }
参考：http://www.cppblog.com/flyinghearts/archive/2010/08/16/123548.html
关于这个题目leetcode有一题很相似，解法更好：
LeetCode Problem: Populating Next Right Pointers in Each Node, Level traversal of binary tree
http://blog.unieagle.net/2012/12/24/leetcode-problem-populating-next-right-pointers-in-each-node-level-traversal-of-binary-tree/
