思路

方法一：輔助佇列儲存對應層數

我們可以用廣度優先搜尋解決這個問題。

我們可以想到最樸素的方法是用一個二元組 (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 };