剑指offer面试题32-II从上到下打印二叉树（层序遍历）

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

思路分析
I. 按层打印： 题目要求的二叉树的 从上至下 打印（即按层打印），又称为二叉树的 广度优先搜索（BFS）。BFS 通常借助 队列 的先入先出特性来实现。
II. 每层打印到一行： 将本层全部节点打印到一行，并将下一层全部节点加入队列，以此类推，即可分为多行打印。
算法流程

1、特例处理： 当根节点为空，则返回空列表 [] ；
2、初始化： 打印结果列表 res = [] ，包含根节点的队列 queue = [root] ；
3、BFS 循环： 当队列 queue 为空时跳出；
       （1）大小：计算队列的大小也就是当前根结点有多少孩子结点；
       （2）新建一个临时列表 tmp ，用于存储当前层打印结果；
       （3）当前层打印循环： 循环次数为当前层节点数（即队列 queue 长度）；
              出队： 队首元素出队，记为 node；
              打印： 将 node.val 添加至 tmp 尾部；
             添加子节点： 若 node 的左（右）子节点不为空，则将左（右）子节点加入队列 queue ；
      （4）将当前层结果 tmp 添加入 res 。
4、返回值： 返回打印结果列表 res 即可。

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) 
    {
         /* 根据函数返回值定义存储结果的变量 */
        vector<vector<int>> result;
        /* 定义一个队列用于存储节点的数据 */
        queue<TreeNode*> que;
        /* 判空 */
        if(root != NULL) que.push(root);

        /* 开始层序遍历 */
        while(!que.empty()) 
        {
            /* 计算队列的大小也即有多少个孩子 */
            int size = que.size();
            /* 定义一个临时vector 存储每一层 */
            vector<int> vec;
            /* 层序遍历 */
            for(int i = 0;i < size; i--) 
            {
                /* 获取第一个节点数据 */
                TreeNode* node = que.front();
                que.pop();

                vec.push_back(node->val);
                if(node->left != NULL) que.push(node->left);
                if(node->right != NULL) que.push(node->right);
            }
            /* 将一层的数据保存 */
            result.push_back(vec);
        }
        return result;
        
    }
};

题目解析
层次遍历二叉树，并将同一层的元素放在一个数组中

为了将同一层的元素放到一个数组容器中，需要两个变量：记录当前层中还没有打印的节点数，以及下一层节点的数目。

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res; // 设置数组容器 res, 用来保存输出结果
        queue<TreeNode*> myQue;  // 设置队列 myQue, 用来存储二叉树中的元素
        // 处理边界
        if (root == nullptr) 
            return res;
        myQue.push(root);  // 队列添加二叉树的根节点
        while (!myQue.empty()) { // 遍历队列，直到队列为空，说明访问了二叉树中所有的节点
            vector<int> tmp; // 临时数组，用来保存每一层的节点，保存成功后添加到res中
            int len = myQue.size(); // 用来记录队列的长度，每层节点的个数
            for (int i = len; i > 0; -- i) {    // 将队列中的元素添加到临时tmp中
                // 从队列中取出一个节点
                TreeNode* node = myQue.front(); // 暂存队头元素 front():返回的是第一个元素的引用
                myQue.pop();  // 删除最后一个元素
                tmp.push_back(node->val);  // 把节点存放到tmp中 push_back():在Vector最后添加一个元素
                // 判断当前节点是否有左/右子节点，添加到队列中
                if(node->left! = nullptr) 
                    myQue.push(node->left);
                if(node->right! = nullptr) 
                    myQue.push(node->right);
            }
            res.push_back(tmp); // 把存放了每一层元素的数组tmp添加到res中
        }    
        return res;
    }
};

递归 

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) 
    {
        if(root == NULL) return {};
         /* 根据函数返回值定义存储结果的变量 */
        vector<vector<int>> res;
        getVals(root,res,0);
        return res;       
    }

    void getVals(TreeNode* node,vector<vector<int>>& res,int level)
    {
        if(node == NULL) return;
        if(level >= res.size())
        {
            vector<int> levelVal;
            res.push_back(levelVal);
        }
        res[level].push_back(node->val);

        getVals(node->left,res,level+1);
        getVals(node->right,res,level+1);    
    }
};