4747``` python
4848# Definition for a binary tree node.
4949# class TreeNode:
50- # def __init__(self, x):
51- # self.val = x
52- # self.left = None
53- # self.right = None
54- 50+ # def __init__(self, val=0, left=None, right=None):
51+ # self.val = val
52+ # self.left = left
53+ # self.right = right
5554class Solution :
5655 def levelOrder (self root : TreeNode) -> List[List[int ]]:
5756 if root is None :
5857 return []
59- res = []
60- q = []
61- q.append(root)
58+ ans = []
59+ q = deque([root])
6260 while q:
63- size = len (q)
61+ n = len (q)
6462 t = []
65- for _ in range (size):
66- node = q.pop(0 )
67- if node.left is not None :
63+ for _ in range (n):
64+ node = q.popleft()
65+ t.append(node.val)
66+ if node.left:
6867 q.append(node.left)
69- if node.rightis not None :
68+ if node.right:
7069 q.append(node.right)
71- t.append(node.val)
72- res.append(t)
73- return res
70+ ans.append(t)
71+ return ans
7472```
7573
7674### ** Java**
@@ -84,27 +82,38 @@ class Solution:
8482 * int val;
8583 * TreeNode left;
8684 * TreeNode right;
87- * TreeNode(int x) { val = x; }
85+ * TreeNode() {}
86+ * TreeNode(int val) { this.val = val; }
87+ * TreeNode(int val, TreeNode left, TreeNode right) {
88+ * this.val = val;
89+ * this.left = left;
90+ * this.right = right;
91+ * }
8892 * }
8993 */
9094class Solution {
9195 public List<List<Integer > > levelOrder (TreeNode root ) {
92- if (root == null ) return Collections . emptyList();
96+ if (root == null ) {
97+ return Collections . emptyList();
98+ }
9399 Deque<TreeNode > q = new ArrayDeque<> ();
94100 q. offer(root);
95- List<List<Integer > > res = new ArrayList<> ();
101+ List<List<Integer > > ans = new ArrayList<> ();
96102 while (! q. isEmpty()) {
97- int size = q. size();
98103 List<Integer > t = new ArrayList<> ();
99- while (size -- > 0 ) {
100- TreeNode node = q. poll ();
104+ for ( int i = 0 , n = q . size(); i < n; ++ i ) {
105+ TreeNode node = q. pollFirst ();
101106 t. add(node. val);
102- if (node. left != null ) q. offer(node. left);
103- if (node. right != null ) q. offer(node. right);
107+ if (node. left != null ) {
108+ q. offer(node. left);
109+ }
110+ if (node. right != null ) {
111+ q. offer(node. right);
112+ }
104113 }
105- res . add(t);
114+ ans . add(t);
106115 }
107- return res ;
116+ return ans ;
108117 }
109118}
110119```
@@ -118,28 +127,108 @@ class Solution {
118127 * int val;
119128 * TreeNode *left;
120129 * TreeNode *right;
121- * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
130+ * TreeNode() : val(0), left(nullptr), right(nullptr) {}
131+ * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
132+ * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
122133 * };
123134 */
124135class Solution {
125136public:
126137 vector<vector<int >> levelOrder(TreeNode* root) {
127138 if (!root) return {};
128- vector<vector<int >> res ;
139+ vector<vector<int >> ans ;
129140 queue<TreeNode* > q{{root}};
130- while (!q.empty()) {
131- vector<int > oneLevel;
132- for (int i = q.size(); i > 0; --i) {
133- TreeNode* t = q.front();
141+ while (!q.empty())
142+ {
143+ vector<int > t;
144+ for (int i = 0, n = q.size(); i < n; ++i)
145+ {
146+ auto node = q.front();
134147 q.pop();
135- oneLevel.push_back(t->val);
136- if (t->left) q.push(t->left);
137- if (t->right) q.push(t->right);
148+ t.push_back(node->val);
149+ if (node->left) q.push(node->left);
150+ if (node->right) q.push(node->right);
151+ }
152+ ans.push_back(t);
153+ }
154+ return ans;
155+ }
156+ };
157+ ```
158+
159+ ### **Go**
160+
161+ ```go
162+ /**
163+ * Definition for a binary tree node.
164+ * type TreeNode struct {
165+ * Val int
166+ * Left *TreeNode
167+ * Right *TreeNode
168+ * }
169+ */
170+ func levelOrder(root *TreeNode) [][]int {
171+ if root == nil {
172+ return nil
173+ }
174+ var ans [][]int
175+ var q = []*TreeNode{root}
176+ for len(q) > 0 {
177+ var t []int
178+ n := len(q)
179+ for i := 0; i < n; i++ {
180+ node := q[0]
181+ q = q[1:]
182+ t = append(t, node.Val)
183+ if node.Left != nil {
184+ q = append(q, node.Left)
185+ }
186+ if node.Right != nil {
187+ q = append(q, node.Right)
188+ }
189+ }
190+ ans = append(ans, t)
191+ }
192+ return ans
193+ }
194+ ```
195+ 196+ ### ** JavaScript**
197+ 198+ ``` js
199+ /**
200+ * Definition for a binary tree node.
201+ * function TreeNode(val, left, right) {
202+ * this.val = (val===undefined ? 0 : val)
203+ * this.left = (left===undefined ? null : left)
204+ * this.right = (right===undefined ? null : right)
205+ * }
206+ */
207+ /**
208+ * @param {TreeNode} root
209+ * @return {number[][]}
210+ */
211+ var levelOrder = function (root ) {
212+ if (! root) {
213+ return [];
214+ }
215+ let ans = [];
216+ let q = [root];
217+ while (q .length ) {
218+ let t = [];
219+ for (let i = 0 , n = q .length ; i < n; ++ i) {
220+ const node = q .shift ();
221+ t .push (node .val );
222+ if (node .left ) {
223+ q .push (node .left );
224+ }
225+ if (node .right ) {
226+ q .push (node .right );
138227 }
139- res.push_back(oneLevel);
140228 }
141- return res ;
229+ ans . push (t) ;
142230 }
231+ return ans;
143232};
144233```
145234
0 commit comments