102. Binary Tree Level Order Traversal

题目：二叉树层序遍历

Given a binary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level).

For example:
Given binary tree [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

return its level order traversal as:

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

题意：

给定一个二叉树，返回该二叉树层序遍历的节点值（即，从左到右，一层接着一层）。

思路一：

递归实现，从根节点起，一层一层的递归，实现相同层的节点放到同一个vector数组中。

代码：C++版：4ms

/**
 * 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>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        traverse(root, 1, res);
        return res;
    }
    void traverse(TreeNode *root, int level, vector<vector<int>> &res) {
        if (!root) return;
        if (level > res.size()) //如果层深大于res的大小时，新增一个vector数组用来保存下一层的值
            res.push_back(vector<int>());
        res[level-1].push_back(root->val);
        traverse(root->left, level+1, res); //递归同一层的左右子树
        traverse(root->right, level+1, res);
    }
};

思路二：

采用迭代实现，借助两个辅助队列实现对当前一层每一个节点的保存，在遍历时，根据current队列找到同一层的所有节点，在遍历过程中，将下一层的节点放入到next'队列中，完成一层的元素遍历之后，交换current，next队列，实现对下一层的遍历，以此类推，实现对整个二叉树的迭代遍历。

代码：C++版：8ms

/**
 * 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>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        if (root == nullptr) return res;
        
        queue<TreeNode *> current, next;
        vector<int> level; //存储每一层的结果
        
        current.push(root);
        while (!current.empty()) {
            while (!current.empty()) {
                TreeNode *node = current.front();
                current.pop();
                level.push_back(node->val);
                if (node->left != nullptr) next.push(node->left);
                if (node->right != nullptr) next.push(node->right);
            }
            res.push_back(level); //将遍历完的每一层的数组放入返回集中
            level.clear(); //清空每一层遍历结果集，为下一层做准备
            swap(next, current); 
        }
        return res;
    }
};

另一种写法，只借助一个队列实现，将每一层的遍历节点都放到同一个队列中，只是通过队列的size区分开本层节点与下一层节点。

代码：C++版：8ms

/**
 * 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>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        if (root == nullptr) return res;
        
        queue<TreeNode*> q;
        q.push(root);
        while (!q.empty()) {
            vector<int> oneLevel;
            int size = q.size(); //利用size来区分每一层的节点
            for (int i=0; i<size; ++i) {  //遍历每一层的所有节点
                TreeNode *node = q.front();
                q.pop();
                oneLevel.push_back(node->val);
                if (node->left) q.push(node->left);
                if (node->right) q.push(node->right);
            }
            res.push_back(oneLevel); //将每一层的节点值遍历结束后放入返回集中。
        }
        return res;
    }
};