剑指 Offer 32 - II. 从上到下打印二叉树 II

思路#

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

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

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

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

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

 1 /**
 2  * Definition for a binary tree node.
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 8  * };
 9  */
10 class Solution {
11 public:
12     vector<vector<int>> levelOrder(TreeNode* root) {
13         vector<vector<int>> res;
14         if(root == NULL)
15             return res;
16         
17         //使用2个队列
18         //队列A：存储节点
19         //队列B：存储节点所在层数
20         queue<TreeNode *> A;
21         queue<int> B;
22 
23         A.push(root);
24         B.push(0);
25 
26         vector<int> v;
27         int currentLevel = 0;
28 
29         while(!A.empty() && !B.empty()) {
30             TreeNode *t = A.front();
31             A.pop();
32 
33             int level = B.front();
34             B.pop();
35 
36             if(level > currentLevel) {
37                 currentLevel++;
38                 res.push_back(v);
39                 v.clear();
40             } 
41 
42             v.push_back(t->val);
43 
44             if(t->left) {
45                 A.push(t->left);
46                 B.push(level+1);
47             }
48 
49             if(t->right) {
50                 A.push(t->right);
51                 B.push(level+1);
52             }
53 
54         }
55 
56         res.push_back(v);
57 
58         return res;
59     }
60 };

方法二：当前层循环打印#

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

 1 /**
 2  * Definition for a binary tree node.
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 8  * };
 9  */
10 class Solution {
11 public:
12     vector<vector<int>> levelOrder(TreeNode* root) {
13         vector<vector<int>> res;
14         if(root == NULL)
15             return res;
16 
17         queue<TreeNode *> Q;
18         Q.push(root);
19 
20         while(!Q.empty()) {
21             vector<int> v;
22             int qsize = Q.size();
23 
24             for(int i = 0; i < qsize; ++i) {
25                 TreeNode *t = Q.front();
26                 Q.pop();
27                 v.push_back(t->val);
28 
29                 if(t->left)
30                     Q.push(t->left);
31                 if(t->right)
32                     Q.push(t->right);
33             }
34 
35             res.push_back(v);
36         }
37 
38         return res;
39     }
40 };