第一种做法做法，用一个数组模拟BFS， 每次把当前数组中的节点的左右儿子保存起来，然后判断当前数组是否为空，不为空就将这个数组一次性存到答案中，然后再找下一层。

class Solution {
public:
    vector<int> getVal(vector<TreeNode*> node) {
        vector<int > res;
        for (auto x:node) {
            res.push_back(x->val);
        }
        return res;
    }

    vector<vector<int>> printFromTopToBottom(TreeNode* root) {
        vector<TreeNode*> node;
        vector<vector<int > > ans;
        if(!root) return ans;
        node.push_back(root);
        ans.push_back(getVal(node));
        while(node.size()) {
            vector<TreeNode*> temp;
            for (auto x : node) {
                if(x->left)temp.push_back(x->left);
                if(x->right)temp.push_back(x->right);
            }
            if(temp.size()) {
                ans.push_back(getVal(temp));
                node=temp;
            }
            else break;
        }
        return ans;
    }
};

第二种做法， 每次bfs存完一层，保存一个NULL， 相当于表示当前层扫完了，当你从队列中取出头部节点时，如果不为空，那么保存这个节点的左右儿子并入队列，如果为空，那么把之前存的这一层全部输出，然后判断队列是不是空，不为空再插入一个NULL节点，否则就退出BFS

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> printFromTopToBottom(TreeNode* root) {
        vector<TreeNode*> node;
        vector<int > num;
        vector<vector<int > > ans;
        if(!root) return ans;
        queue<TreeNode*> q;
        q.push(root);
        q.push(NULL);
        // num.push_back(root->val);
        while(!q.empty()) {
            TreeNode* temp = q.front();
            q.pop();
            if(temp) {
                num.push_back(temp->val);
                if(temp->left) q.push(temp->left);
                if(temp->right) q.push(temp->right);
            }
            else {
                ans.push_back(num);
                num.clear();
                if(q.empty()) break;
                else q.push(NULL);
            }
        }
        return ans;
    }
};