feat: add solutions to lc problem: No.0107 (doocs#2344)

No.0107.Binary Tree Level Order Traversal II

Author: yanglbme

solution/0100-0199/0107.Binary Tree Level Order Traversal II/README.md

@@ -44,7 +44,12 @@
 
 ### 方法一：BFS
 
-思路同 [102](https://github.com/doocs/leetcode/blob/main/solution/0100-0199/0102.Binary%20Tree%20Level%20Order%20Traversal/README.md)，最后反转一下结果即可。
+我们可以使用 BFS 的方法来解决这道题。首先将根节点入队，然后不断地进行以下操作，直到队列为空：
+
+-   遍历当前队列中的所有节点，将它们的值存储到一个临时数组 $t$ 中，然后将它们的孩子节点入队。
+-   将临时数组 $t$ 存储到答案数组中。
+
+最后将答案数组反转后返回即可。
 
 时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是二叉树的节点个数。
 
@@ -135,18 +140,24 @@ class Solution {
 public:
     vector<vector<int>> levelOrderBottom(TreeNode* root) {
         vector<vector<int>> ans;
-        if (!root) return ans;
+        if (!root) {
+            return ans;
+        }
         queue<TreeNode*> q{{root}};
         while (!q.empty()) {
             vector<int> t;
-            for (int i = q.size(); i; --i) {
+            for (int n = q.size(); n; --n) {
                 auto node = q.front();
                 q.pop();
-                t.emplace_back(node->val);
-                if (node->left) q.push(node->left);
-                if (node->right) q.push(node->right);
+                t.push_back(node->val);
+                if (node->left) {
+                    q.push(node->left);
+                }
+                if (node->right) {
+                    q.push(node->right);
+                }
             }
-            ans.emplace_back(t);
+            ans.push_back(t);
         }
         reverse(ans.begin(), ans.end());
         return ans;
@@ -163,15 +174,14 @@ public:
  *     Right *TreeNode
  * }
  */
-func levelOrderBottom(root *TreeNode) [][]int {
-	ans := [][]int{}
+func levelOrderBottom(root *TreeNode) (ans [][]int) {
 	if root == nil {
-		return ans
+		return
 	}
 	q := []*TreeNode{root}
 	for len(q) > 0 {
-		var t []int
-		for i := len(q); i > 0; i-- {
+		t := []int{}
+		for n := len(q); n > 0; n-- {
 			node := q[0]
 			q = q[1:]
 			t = append(t, node.Val)
@@ -182,9 +192,48 @@ func levelOrderBottom(root *TreeNode) [][]int {
 				q = append(q, node.Right)
 			}
 		}
-		ans = append([][]int{t}, ans...)
+		ans = append(ans, t)
+	}
+	for i, j := 0, len(ans)-1; i < j; i, j = i+1, j-1 {
+		ans[i], ans[j] = ans[j], ans[i]
 	}
-	return ans
+	return
+}
+```
+
+```ts
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *     val: number
+ *     left: TreeNode | null
+ *     right: TreeNode | null
+ *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *     }
+ * }
+ */
+
+function levelOrderBottom(root: TreeNode | null): number[][] {
+    const ans: number[][] = [];
+    if (!root) {
+        return ans;
+    }
+    const q: TreeNode[] = [root];
+    while (q.length) {
+        const t: number[] = [];
+        const qq: TreeNode[] = [];
+        for (const { val, left, right } of q) {
+            t.push(val);
+            left && qq.push(left);
+            right && qq.push(right);
+        }
+        ans.push(t);
+        q.splice(0, q.length, ...qq);
+    }
+    return ans.reverse();
 }
 ```
 
@@ -209,38 +258,30 @@ func levelOrderBottom(root *TreeNode) [][]int {
 // }
 use std::{ rc::Rc, cell::RefCell, collections::VecDeque };
 impl Solution {
-    #[allow(dead_code)]
     pub fn level_order_bottom(root: Option<Rc<RefCell<TreeNode>>>) -> Vec<Vec<i32>> {
-        if root.is_none() {
-            return vec![];
-        }
-        let mut ret_vec = Vec::new();
-        let mut q = VecDeque::new();
-
-        q.push_back(root);
-
-        while !q.is_empty() {
-            let mut cur_vec = Vec::new();
-            let mut next_q = VecDeque::new();
+        let mut ans = Vec::new();
+        if let Some(root_node) = root {
+            let mut q = VecDeque::new();
+            q.push_back(root_node);
             while !q.is_empty() {
-                let cur_front = q.front().unwrap().clone();
-                q.pop_front();
-                cur_vec.push(cur_front.as_ref().unwrap().borrow().val);
-                let left = cur_front.as_ref().unwrap().borrow().left.clone();
-                let right = cur_front.as_ref().unwrap().borrow().right.clone();
-                if !left.is_none() {
-                    next_q.push_back(left);
-                }
-                if !right.is_none() {
-                    next_q.push_back(right);
+                let mut t = Vec::new();
+                for _ in 0..q.len() {
+                    if let Some(node) = q.pop_front() {
+                        let node_ref = node.borrow();
+                        t.push(node_ref.val);
+                        if let Some(ref left) = node_ref.left {
+                            q.push_back(Rc::clone(left));
+                        }
+                        if let Some(ref right) = node_ref.right {
+                            q.push_back(Rc::clone(right));
+                        }
+                    }
                 }
+                ans.push(t);
             }
-            ret_vec.push(cur_vec);
-            q = next_q;
         }
-
-        ret_vec.reverse();
-        ret_vec
+        ans.reverse();
+        ans
     }
 }
 ```
@@ -260,19 +301,22 @@ impl Solution {
  */
 var levelOrderBottom = function (root) {
     const ans = [];
-    if (!root) return ans;
+    if (!root) {
+        return ans;
+    }
     const q = [root];
     while (q.length) {
         const t = [];
-        for (let i = q.length; i > 0; --i) {
-            const node = q.shift();
-            t.push(node.val);
-            if (node.left) q.push(node.left);
-            if (node.right) q.push(node.right);
+        const qq = [];
+        for (const { val, left, right } of q) {
+            t.push(val);
+            left && qq.push(left);
+            right && qq.push(right);
         }
-        ans.unshift(t);
+        ans.push(t);
+        q.splice(0, q.length, ...qq);
     }
-    return ans;
+    return ans.reverse();
 };
 ```