day23：44. 分行从上往下打印二叉树（层序遍历）（BFS） LeetCode 429. N 叉树的层序遍历

问题描述：
从上到下按层打印二叉树，同一层的结点按从左到右的顺序打印，每一层打印到一行。

样例

版本一：
二叉树的遍历，使用到了队列，本题中使用到了广度优先遍历，并且还要求区分每一层。设置一个nullptr来区分层与层。在每一层技术的时候加入nullptr，以表示上一层结束，进入了下一层，首先遍历根节点，根节点可以看做一层，所以加入nullptr，然后遍历下一层，利用队列先进先出的性质，先找到第一个节点，然后将该节点的值放入到res中，如果该节点有左右子节点，那么将其放入队列q中，如果该节点为空，那么意味着到了nullptr这一块，此时需要将level的值放入到res中，并且将level清空，以便下次使用，然后需要在队列后面加入nullptr,由于之前已经将左右子节点加入进去了，所以，此次加入nullptr是在该层结束之后加入的。

class Solution {
public:
    vector<vector<int>> printFromTopToBottom(TreeNode* root) {
        vector<vector<int>> res;
        if(!root) return res;
        
        queue<TreeNode*> q;
        q.push(root);
        q.push(nullptr);
        
        vector<int> level;
        while(q.size())
        {
            auto t=q.front();
            q.pop();
            if(!t)
            {
                if(level.empty()) break;            
                res.push_back(level);
                level.clear();
                q.push(nullptr);
                continue;
            
            }
            level.push_back(t->val);
            if(t->left) q.push(t->left);
            if(t->right) q.push(t->right);
        }
        return res;
    }
};

版本二：

class Solution {
public:
       vector<vector<int> > Print(TreeNode* pRoot) {
           queue<TreeNode*> q;
           vector<vector<int> >res;
           
           if(pRoot) q.push(pRoot);
          
           while(!q.empty())
           {     
               vector<int> path;
               int n = q.size();
               while(n--)
               {
                   TreeNode* t=q.front();
                   q.pop();
                   path.push_back(t->val);
                   if(t->left) q.push(t->left);
                   if(t->right) q.push(t->right);
               }
               res.push_back(path);
             
           }
           return res;
        }
    
};

429. N 叉树的层序遍历
给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。
示例 1：

输入：root = [1,null,3,2,4,null,5,6]
输出：[[1],[3,2,4],[5,6]]
示例 2：

输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出：[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]

只需要将根节点的孩子节点这行变一下即可。

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/
class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        queue<Node*> q;
        vector<vector<int>> ans;
        if(root) q.push(root);
        while(q.size())
        {
            int s=q.size();
            vector<int> path;
            while(s--)
            {
                auto t=q.front(); q.pop();
                path.push_back(t->val);
                for(int i=0;i<t->children.size();i++)  if(t->children[i]) q.push(t->children[i]);                
            }      
            ans.push_back(path);
        }
        return ans;
    }
};