[0204]ADD:LC-many

Author: Coder-AndyLee

readme.md

@@ -18,6 +18,10 @@
 [[20200201]647. 回文子串-Medium](动态规划/区间序列/647.%20回文子串-Medium.md)  
 [[20200201]111. 二叉树的最小深度-Easy](树/111.%20二叉树的最小深度-Easy.md)   
 [[20210203]752. 打开转盘锁-Medium](回溯法/BFS/752.%20打开转盘锁-Medium.md)  
+[[20210204]107. 二叉树的层序遍历 II-Easy](树/107.%20二叉树的层序遍历%20II-Easy.md)   
+[[20210204]637. 二叉树的层平均值-Easy](树/637.%20二叉树的层平均值-Easy.md)  
+[[20210204]429. N 叉树的层序遍历-Medium](树/429.%20N%20叉树的层序遍历-Medium.md)   
+[[20210204]1161. 最大层内元素和-Medium](1161.%20最大层内元素和-Medium.md)  
 ## 2020.12
 [[20201201]34. 在排序数组中查找元素的第一个和最后一个位置-Medium](数组/34.%20在排序数组中查找元素的第一个和最后一个位置-Medium.md)  
 [[20201202]292. Nim 游戏-Easy](动态规划/292.%20Nim%20游戏-Easy.md)  
@@ -87,18 +91,23 @@
 # 按类别归类
 ## 树
 [102. 二叉树的层序遍历 - Medium](./树/102.%20二叉树的层序遍历%20-%20Medium.md)  
+[107. 二叉树的层序遍历 II-Easy](树/107.%20二叉树的层序遍历%20II-Easy.md)   
 [111. 二叉树的最小深度-Easy](树/111.%20二叉树的最小深度-Easy.md)   
  [129. 求根到叶子节点数字之和-Medium](树/129.%20求根到叶子节点数字之和-Medium.md)  
  [144. 二叉树的前序遍历-Medium](树/144.%20二叉树的前序遍历-Medium.md)  
 [235. 二叉搜索树的最近公共祖先-Easy](./树/235.%20二叉搜索树的最近公共祖先-Easy.md)   
 [297. 二叉树的序列化与反序列化-Hard](树/297.%20二叉树的序列化与反序列化-Hard.md)  
+[429. N 叉树的层序遍历-Medium](树/429.%20N%20叉树的层序遍历-Medium.md)  
 [449. 序列化和反序列化二叉搜索树-Medium](树/449.%20序列化和反序列化二叉搜索树-Medium.md)  
 [501. 二叉搜索树中的众数 - Easy](501.%20二叉搜索树中的众数%20-%20Easy.md)  
 [589. N叉树的前序遍历 - Easy](./树/589.%20N叉树的前序遍历%20-%20Easy.md)  
 [617. 合并二叉树 - Easy](./树/617.%20合并二叉树%20-%20Easy.md)  
+[637. 二叉树的层平均值-Easy](树/637.%20二叉树的层平均值-Easy.md)  
 [897. 递增顺序查找树 - Easy](./树/897.%20递增顺序查找树%20-%20Easy.md)  
+[1161. 最大层内元素和-Medium](1161.%20最大层内元素和-Medium.md)  
 [剑指 Offer 26. 树的子结构-Medium](./树/剑指%20Offer%2026.%20树的子结构-Medium.md)  
 [剑指 Offer 54. 二叉搜索树的第k大节点 - Easy](./树/剑指%20Offer%2054.%20二叉搜索树的第k大节点%20-%20Easy.md)   
+
 
 ## 数组和双指针
 [15. 三数之和 - Medium](双指针/15.%20三数之和%20-%20Medium.md)   

树/107. 二叉树的层序遍历 II-Easy.md

@@ -0,0 +1,51 @@
+# [Description](https://leetcode-cn.com/problems/binary-tree-level-order-traversal)
+
+给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。
+
+ 
+
+示例：
+```python
+二叉树：[3,9,20,null,null,15,7],
+
+    3
+   / \
+  9  20
+    /  \
+   15   7
+返回其层序遍历结果：
+
+[
+  [3],
+  [9,20],
+  [15,7]
+]
+```
+
+# Solution
+- 时间复杂度：$O(n)$
+- 空间复杂度：$O(n)$
+
+```python
+class Solution:
+    def levelOrder(self, root: TreeNode) -> List[List[int]]:
+        if not root:
+            return []
+        else:
+            ans, stack = [], [root]
+            while stack:
+                layer_node, layer_val = [], []
+                while stack:
+                    current = stack.pop(0)
+                    layer_val.append(current.val)
+
+                    if current.left:
+                        layer_node.append(current.left)
+                    if current.right:
+                        layer_node.append(current.right)
+                
+                stack.extend(layer_node)
+                ans.append(layer_val)
+            
+            return ans
+```

树/1161. 最大层内元素和-Medium.md

@@ -0,0 +1,66 @@
+# [Description](https://leetcode-cn.com/problems/maximum-level-sum-of-a-binary-tree)
+给你一个二叉树的根节点 root。设根节点位于二叉树的第 1 层，而根节点的子节点位于第 2 层，依此类推。
+
+请你找出层内元素之和 最大 的那几层（可能只有一层）的层号，并返回其中 最小 的那个。
+
+ 
+
+示例 1：
+
+![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/08/17/capture.jpeg)
+```python
+输入：root = [1,7,0,7,-8,null,null]
+输出：2
+解释：
+第 1 层各元素之和为 1，
+第 2 层各元素之和为 7 + 0 = 7，
+第 3 层各元素之和为 7 + -8 = -1，
+所以我们返回第 2 层的层号，它的层内元素之和最大。
+```
+示例 2：
+```python
+输入：root = [989,null,10250,98693,-89388,null,null,null,-32127]
+输出：2
+```
+
+提示：
+
+- 树中的节点数介于 1 和 10^4 之间
+- $-10^5 <= node.val <= 10^5$
+
+# Solution
+- 需要注意节点的取值可为负数。
+- 时间复杂度：$O(n)$
+- 空间复杂度：$O(n)$
+
+```python
+class Solution:
+    def maxLevelSum(self, root: TreeNode) -> int:
+        if not root:
+            return 0
+        queue = [root]
+        tmp_index = 1
+        index = 0
+        final_total = float('-inf')
+
+        while queue:
+            total = 0
+            tmp_length = len(queue)
+
+            for i in range(tmp_length):
+                tmp_node = queue.pop(0)
+                total += tmp_node.val
+
+                if tmp_node.left:
+                    queue.append(tmp_node.left)
+                if tmp_node.right:
+                    queue.append(tmp_node.right)
+
+            if total > final_total:
+                final_total = total
+                index = tmp_index
+
+            tmp_index += 1
+
+        return index
+```

树/429. N 叉树的层序遍历-Medium.md

@@ -0,0 +1,52 @@
+# [Description](https://leetcode-cn.com/problems/n-ary-tree-level-order-traversal)
+给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。
+
+树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。
+
+ 
+
+示例 1：
+![](https://assets.leetcode.com/uploads/2018/10/12/narytreeexample.png)
+```python
+输入：root = [1,null,3,2,4,null,5,6]
+输出：[[1],[3,2,4],[5,6]]
+```
+示例 2：
+![](https://assets.leetcode.com/uploads/2019/11/08/sample_4_964.png)
+```python
+输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
+输出：[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]
+```
+
+提示：
+
+- 树的高度不会超过 1000
+- 树的节点总数在 [0, 10^4] 之间
+
+
+# Solution
+- 时间复杂度：$O(n)$
+- 空间复杂度：$O(n)$
+
+```python
+class Solution:
+    def levelOrder(self, root: 'Node') -> List[List[int]]:
+        if not root:
+            return []
+        queue = [root]
+        ans = []
+
+        while queue:
+            tmp_list = []
+            tmp_length = len(queue)
+
+            for i in range(tmp_length):
+                tmp_node = queue.pop(0)
+                tmp_list.append(tmp_node.val)
+
+                for node in tmp_node.children:
+                    queue.append(node)
+
+            ans.append(tmp_list)
+        return ans
+```

树/637. 二叉树的层平均值-Easy.md

@@ -0,0 +1,52 @@
+# [Description](https://leetcode-cn.com/problems/average-of-levels-in-binary-tree)
+
+给定一个非空二叉树, 返回一个由每层节点平均值组成的数组。
+
+
+示例 1：
+```python
+输入：
+    3
+   / \
+  9  20
+    /  \
+   15   7
+输出：[3, 14.5, 11]
+解释：
+第 0 层的平均值是 3 ,  第1层是 14.5 , 第2层是 11 。因此返回 [3, 14.5, 11] 。
+```
+
+提示：
+
+- 节点值的范围在32位有符号整数范围内。
+
+# Solution
+- 时间复杂度：$O(n)$
+- 空间复杂度：$O(n)$
+
+
+```python
+class Solution:
+    def averageOfLevels(self, root: TreeNode) -> List[float]:
+        if not root:
+            return []
+        queue = [root]
+        ans = []
+
+        while queue:
+            total, length = 0, 0
+            tmp_length = len(queue)
+
+            for i in range(tmp_length):
+                tmp_node = queue.pop(0)
+                total += tmp_node.val
+                length += 1
+
+                if tmp_node.left:
+                    queue.append(tmp_node.left)
+                if tmp_node.right:
+                    queue.append(tmp_node.right)
+
+            ans.append(total/length)
+        return ans
+```