给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

示例 2：

输入：root = [1]
输出：[[1]]

示例 3：

输入：root = []
输出：[]

提示：

树中节点数目在范围 $[0,2000]$ 内
$-1000<=Node.val<=1000$

解法一：
思路：

• 每层一个 vector，相当于二维数组的一行
• 每次遍历一行（一层）
• 对于每层遍历：
  • 新创建一个 vector，用于记录下一层的节点
  • 如果当前节点做左子节点，则加入 下层的 vector 数组
  • 如果当前节点做右子节点，则加入 下层的 vector 数组
• 逐层遍历，直到没有下一层

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<TreeNode*>> res;
        vector<vector<int>> ans;
        if(root == nullptr) return ans;
        int l = 0;
        while(res.size() >= l){
            vector<TreeNode*> v;
            vector<int> q;
            if(!l) v.push_back(root), q.push_back(root -> val);
            else{
                int n = res[l-1].size();
                for(int i = 0; i < n; i++){
                    TreeNode* cur = res[l-1][i];
                    if(cur -> left != nullptr) v.push_back(cur -> left), q.push_back(cur -> left -> val);
                    if(cur -> right != nullptr) v.push_back(cur -> right), q.push_back(cur -> right -> val);
                }
            }
            if(v.size()) res.push_back(v);
            if(q.size()) ans.push_back(q);
            l++;
        }
        return ans;
    }
};

解法二：
思路：

• 通过队列来进行搜索（bfs）
• 在 bfs 基础上，遍历每层前，用 temp 变量 提前记录 当前层最后一个节点的位置
• 遍历当前层的每个节点
  • 如果当前节点做左子节点，则加入 下层的 vector 数组
  • 如果当前节点做右子节点，则加入 下层的 vector 数组
• 逐层遍历，直到没有下一层

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> ans;
        TreeNode* q[2010];
        if(root == nullptr) return ans;
        int hh = 0, tt = -1;
        q[++tt] = root;
        vector<int> v;
        v.push_back(root -> val);
        ans.push_back(v);
        while(hh <= tt){
            int temp = tt;
            vector<int> v;
            while(hh <= temp){
                auto cur = q[hh++];
                if(cur -> left != nullptr) q[++tt] = cur -> left, v.push_back(q[tt]->val);
                if(cur -> right != nullptr) q[++tt] = cur -> right, v.push_back(q[tt]->val);
            }
            if(v.size()) ans.push_back(v);
        }
        return ans;
    }
};