[LintCode]69.二叉树的层次遍历

给出一棵二叉树，返回其节点值的层次遍历（逐层从左往右访问）

样例

给一棵二叉树 {3,9,20,#,#,15,7} ：

  3
 / \
9  20
  /  \
 15   7

返回他的分层遍历结果：

[
  [3],
  [9,20],
  [15,7]
]

用一个队列实现，队列保存每层的节点，以此遍历每层。 广度优先遍历？

层次遍历要考虑用队列来存放数据了，所以首先把根节点放进队列，之后开始每次判断队列不空则要建立一个vector来存每一层的数，为了隔开每一层的数一定要记得对vector里push完一层就要清空队始列！！最后把每一个小分组push进一个向量里面。   每出队一个节点就把该节点的左右孩子加入到队列
中（即下一层的节点），队头节点就是接下来要遍历的节点，直到叶子节点没有左右子树进而没有新节点入队，知道队列为空时遍历结束。
根据对每一层数据的个数计数判断哪里停止一层数据的划分。

/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */
 
class Solution {
    /**
     * @param root: The root of binary tree.
     * @return: Level order a list of lists of integer
     */
public:
    vector<vector<int>> levelOrder(TreeNode *root) {
        vector<vector<int>> w;
        if(root==NULL){
            return w;
        }
        queue<TreeNode*> que;
        que.push(root);
        int len=1;//对每一层数据的个数计数
     
        while(!que.empty()){
            vector<int> level;//存每一层的数
            len=que.size();//记录该层节点的总个
    //循环的目的是将该层的所有节点出队,并且把它们的孩子全部压入队列中         
            while(len--){
                TreeNode *temp=que.front();//队头节点
                level.push_back(temp->val);//该层节点的值放入数组中
                que.pop();//隔开每一层的数,vector里push完一层就要清空队始列
                
                if(temp->left!=NULL){
                    que.push(temp->left);
                }
                if(temp->right!=NULL){
                    que.push(temp->right);
                }
            }
            w.push_back(level);
        }
        return w;
    }
};

1.初始化时，last=1，把1放入队列；

2.将1出队，把1的子孩子2,3放入队列，更新nlast=3；

3.nlast更新完之后，打印上一次出队的1，并和last比较，如果相同就打印换行，并更新last=nlast=3;

4.将2出队，把2的子孩子4放入队列，更新nlast=4;

5,nlast更新完以后，打印上一次出队的2，并和last（3）比较，不相同，continue；

6.将3出队，将3的子孩子5，6放入队列，更新nlast=6;

7.nlast更新完以后，打印上一次出队的3，并和last（3）比较， 相同就打印换行，并更新last=nlast=6;

…………

总结如下：（初始化last=根节点）

1.将A出队，并将A的子孩子入队，更新nlast=A最后入队的子孩子；

2.打印上次出队的家伙A，并和last比较，如果相同就打印换行，并更新last=nlast，如果不相同，则continue

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};*/

class TreePrinter {
public:
    vector<vector<int> > printTree(TreeNode* root) {
        vector<vector<int> > pTree;
        queue<TreeNode*> que;//处理数据队列
        vector<int> temp;// 存储每一层数据
        if(root==NULL)
            return pTree;
        TreeNode* last = root;
        TreeNode* nLast = root;
        que.push(root);
        while(!que.empty()){
            TreeNode* proot=que.front();
            que.pop();
            temp.push_back(proot->val);
            if(proot->left){
                que.push(proot->left);
                nLast = proot->left;
            }
            if(proot->right){
                que.push(proot->right);
                nLast = proot->right;
            }
            if(proot==last){
                pTree.push_back(temp);
                last=nLast;
                temp.clear();
            }
        }
        return pTree;
    }
};