剑指 Offer 32

思路

方法一：辅助队列保存对应层数

我们可以用广度优先搜索解决这个问题。

我们可以想到最朴素的方法是用一个二元组 (node, level) 来表示状态，它表示某个节点和它所在的层数，每个新进队列的节点的 level 值都是父亲节点的 level 值加一。

最后根据每个点的 level 对点进行分类，分类的时候我们可以利用哈希表，维护一个以 level 为键，对应节点值组成的数组为值，广度优先搜索结束以后按键 level 从小到大取出所有值，组成答案返回即可。

但是这里已经TreeNode结构已经被LeetCode内部定死了，修改不了，所以可以使用一个额外的队列专门保存层数。

/**
 * 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 == NULL)
            return res;
        
        //使用2个队列
        //队列A：存储节点
        //队列B：存储节点所在层数
        queue<TreeNode *> A;
        queue<int> B;

        A.push(root);
        B.push(0);

        vector<int> v;
        int currentLevel = 0;

        while(!A.empty() && !B.empty()) {
            TreeNode *t = A.front();
            A.pop();

            int level = B.front();
            B.pop();

            if(level > currentLevel) {
                currentLevel++;
                res.push_back(v);
                v.clear();
            } 

            v.push_back(t->val);

            if(t->left) {
                A.push(t->left);
                B.push(level+1);
            }

            if(t->right) {
                A.push(t->right);
                B.push(level+1);
            }

        }

        res.push_back(v);

        return res;
    }
};

方法二：当前层循环打印

当前层循环打印： 循环次数为当前层节点数（即队列 queue 长度）；
在添加子节点之前，先保存当前队列的长度qsize，循环出队并打印qsize次就能打印当前层的所有元素。

/**
 * 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 == NULL)
            return res;

        queue<TreeNode *> Q;
        Q.push(root);

        while(!Q.empty()) {
            vector<int> v;
            int qsize = Q.size();

            for(int i = 0; i < qsize; ++i) {
                TreeNode *t = Q.front();
                Q.pop();
                v.push_back(t->val);

                if(t->left)
                    Q.push(t->left);
                if(t->right)
                    Q.push(t->right);
            }

            res.push_back(v);
        }

        return res;
    }
};

复杂度分析