feat: add solutions to lcof problems: No.32.1,32.2

Author: yanglbme

lcof/面试题30. 包含min函数的栈/README.md

@@ -50,30 +50,27 @@ minStack.min();   --> 返回 -2.
 ```python
 class MinStack:
     def __init__(self):
-        """
-        initialize your data structure here.
-        """
-        self.s = []
-        self.mins = [inf]
+        self.stk1 = []
+        self.stk2 = [inf]
 
-    def push(self, val: int) -> None:
-        self.s.append(val)
-        self.mins.append(min(self.mins[-1], val))
+    def push(self, x: int) -> None:
+        self.stk1.append(x)
+        self.stk2.append(min(x, self.stk2[-1]))
 
     def pop(self) -> None:
-        self.s.pop()
-        self.mins.pop()
+        self.stk1.pop()
+        self.stk2.pop()
 
     def top(self) -> int:
-        return self.s[-1]
+        return self.stk1[-1]
 
     def getMin(self) -> int:
-        return self.mins[-1]
+        return self.stk2[-1]
 
 
 # Your MinStack object will be instantiated and called as such:
 # obj = MinStack()
-# obj.push(val)
+# obj.push(x)
 # obj.pop()
 # param_3 = obj.top()
 # param_4 = obj.getMin()
@@ -165,48 +162,6 @@ private:
  */
 ```
 
-### **TypeScript**
-
-```ts
-class MinStack {
-    stack: number[];
-    mins: number[];
-    constructor() {
-        this.stack = [];
-        this.mins = [];
-    }
-
-    push(x: number): void {
-        this.stack.push(x);
-        this.mins.push(Math.min(this.getMin(), x));
-    }
-
-    pop(): void {
-        this.stack.pop();
-        this.mins.pop();
-    }
-
-    top(): number {
-        return this.stack[this.stack.length - 1];
-    }
-
-    getMin(): number {
-        return this.mins.length == 0
-            ? Infinity
-            : this.mins[this.mins.length - 1];
-    }
-}
-
-/**
- * Your MinStack object will be instantiated and called as such:
- * var obj = new MinStack()
- * obj.push(x)
- * obj.pop()
- * var param_3 = obj.top()
- * var param_4 = obj.getMin()
- */
-```
-
 ### **Go**
 
 ```go
@@ -255,6 +210,48 @@ func min(a, b int) int {
  */
 ```
 
+### **TypeScript**
+
+```ts
+class MinStack {
+    stack: number[];
+    mins: number[];
+    constructor() {
+        this.stack = [];
+        this.mins = [];
+    }
+
+    push(x: number): void {
+        this.stack.push(x);
+        this.mins.push(Math.min(this.getMin(), x));
+    }
+
+    pop(): void {
+        this.stack.pop();
+        this.mins.pop();
+    }
+
+    top(): number {
+        return this.stack[this.stack.length - 1];
+    }
+
+    getMin(): number {
+        return this.mins.length == 0
+            ? Infinity
+            : this.mins[this.mins.length - 1];
+    }
+}
+
+/**
+ * Your MinStack object will be instantiated and called as such:
+ * var obj = new MinStack()
+ * obj.push(x)
+ * obj.pop()
+ * var param_3 = obj.top()
+ * var param_4 = obj.getMin()
+ */
+```
+
 ### **Rust**
 
 ```rust

lcof/面试题32 - I. 从上到下打印二叉树/README.md

@@ -31,6 +31,12 @@
 
 ## 解法
 
+**方法一：BFS**
+
+我们可以通过 BFS 遍历二叉树，将每一层的节点值存入数组中，最后返回数组即可。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为二叉树的节点数。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -46,21 +52,19 @@
 
 class Solution:
     def levelOrder(self, root: TreeNode) -> List[int]:
+        ans = []
         if root is None:
-            return []
-        q = deque()
-        q.append(root)
-        res = []
+            return ans
+        q = deque([root])
         while q:
-            size = len(q)
-            for _ in range(size):
+            for _ in range(len(q)):
                 node = q.popleft()
-                res.append(node.val)
+                ans.append(node.val)
                 if node.left:
                     q.append(node.left)
                 if node.right:
                     q.append(node.right)
-        return res
+        return ans
 ```
 
 ### **Java**
@@ -77,116 +81,133 @@ class Solution:
  */
 class Solution {
     public int[] levelOrder(TreeNode root) {
-        if (root == null) return new int[] {};
+        if (root == null) {
+            return new int[] {};
+        }
         Deque<TreeNode> q = new ArrayDeque<>();
-        List<Integer> t = new ArrayList<>();
         q.offer(root);
+        List<Integer> res =  new ArrayList<>();
         while (!q.isEmpty()) {
-            int size = q.size();
-            while (size-- > 0) {
+            for (int n = q.size(); n > 0; --n) {
                 TreeNode node = q.poll();
-                t.add(node.val);
-                if (node.left != null) q.offer(node.left);
-                if (node.right != null) q.offer(node.right);
+                res.add(node.val);
+                if (node.left != null) {
+                    q.offer(node.left);
+                }
+                if (node.right != null) {
+                    q.offer(node.right);
+                }
             }
         }
-        int i = 0, n = t.size();
-        int[] res = new int[n];
-        for (Integer e : t) {
-            res[i++] = e;
+        int[] ans = new int[res.size()];
+        for (int i = 0; i < ans.length; ++i) {
+            ans[i] = res.get(i);
         }
-        return res;
+        return ans;
     }
 }
 ```
 
-### **JavaScript**
+### **C++**
 
-```js
+```cpp
 /**
  * Definition for a binary tree node.
- * function TreeNode(val) {
- *     this.val = val;
- *     this.left = this.right = null;
- * }
- */
-/**
- * @param {TreeNode} root
- * @return {number[]}
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
  */
-var levelOrder = function (root) {
-    if (!root) return [];
-    let queue = [root];
-    let res = [];
-    while (queue.length) {
-        let node = queue.shift();
-        if (!node) continue;
-        res.push(node.val);
-        queue.push(node.left, node.right);
+class Solution {
+public:
+    vector<int> levelOrder(TreeNode* root) {
+        if (!root) {
+            return {};
+        }
+        vector<int> ans;
+        queue<TreeNode*> q{{root}};
+        while (!q.empty()) {
+            for (int n = q.size(); n; --n) {
+                auto node = q.front();
+                q.pop();
+                ans.push_back(node->val);
+                if (node->left) {
+                    q.push(node->left);
+                }
+                if (node->right) {
+                    q.push(node->right);
+                }
+            }
+        }
+        return ans;
     }
-    return res;
 };
 ```
 
 ### **Go**
 
 ```go
-func levelOrder(root *TreeNode) []int {
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func levelOrder(root *TreeNode) (ans []int) {
 	if root == nil {
-		return []int{}
+		return
 	}
-	q := []*TreeNode{}
-	q = append(q, root)
-	// 层序遍历,用队列,遍历到谁,就把谁的左右结点加入队列
-	res := []int{}
-	for len(q) != 0 {
-		tmp := q[0]
-		q = q[1:]
-		res = append(res, tmp.Val)
-		if tmp.Left != nil {
-			q = append(q, tmp.Left)
-		}
-		if tmp.Right != nil {
-			q = append(q, tmp.Right)
+	q := []*TreeNode{root}
+	for len(q) > 0 {
+		for n := len(q); n > 0; n-- {
+			node := q[0]
+			q = q[1:]
+			ans = append(ans, node.Val)
+			if node.Left != nil {
+				q = append(q, node.Left)
+			}
+			if node.Right != nil {
+				q = append(q, node.Right)
+			}
 		}
 	}
-	return res
+	return
 }
 ```
 
-### **C++**
+### **JavaScript**
 
-```cpp
+```js
 /**
  * Definition for a binary tree node.
- * struct TreeNode {
- *     int val;
- *     TreeNode *left;
- *     TreeNode *right;
- *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
- * };
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
  */
-class Solution {
-public:
-    vector<int> levelOrder(TreeNode* root) {
-        vector<int> res;
-        queue<TreeNode*> q;
-        if (root != nullptr) {
-            q.push(root);
-        }
-        while (!q.empty()) {
-            TreeNode* node = q.front();
-            q.pop();
-            if (node->left != nullptr) {
-                q.push(node->left);
-            }
-            if (node->right != nullptr) {
-                q.push(node->right);
-            }
-            res.push_back(node->val);
+/**
+ * @param {TreeNode} root
+ * @return {number[]}
+ */
+var levelOrder = function (root) {
+    if (!root) {
+        return [];
+    }
+    const q = [root];
+    const ans = [];
+    while (q.length) {
+        for (let n = q.length; n; --n) {
+            const { val, left, right } = q.shift();
+            ans.push(val);
+            left && q.push(left);
+            right && q.push(right);
         }
-        return res;
     }
+    return ans;
 };
 ```