给其他几道题目添加了python的代码

problems/0102.二叉树的层序遍历.md

@@ -99,7 +99,7 @@ class Solution:
 
         while quene:
             in_list = []
-            for i in range(len(quene)):
+            for _ in range(len(quene)):
                 node = quene.pop(0)
                 in_list.append(node.val)
                 if node.left:
@@ -185,6 +185,43 @@ public:
     }
 };
 ```
+python代码：
+
+```python
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def levelOrderBottom(self, root: TreeNode) -> List[List[int]]:
+        if not root:
+            return []
+        quene = [root]
+        out_list = []
+        
+        while quene:
+            in_list = []
+            for _ in range(len(quene)):
+                node = quene.pop(0)
+                in_list.append(node.val)
+                if node.left:
+                    quene.append(node.left)
+                if node.right:
+                    quene.append(node.right)
+ 
+            out_list.append(in_list)
+    
+        out_list.reverse()
+        return out_list
+    
+# 执行用时：36 ms, 在所有 Python3 提交中击败了92.00%的用户
+# 内存消耗：15.2 MB, 在所有 Python3 提交中击败了63.76%的用户
+```
+
+
+
 javascript代码
 
 ```javascript
@@ -246,6 +283,50 @@ public:
     }
 };
 ```
+python代码：
+
+```python
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def rightSideView(self, root: TreeNode) -> List[int]:
+        if not root:
+            return []
+        
+        # deque来自collections模块，不在力扣平台时，需要手动写入
+        # 'from collections import deque' 导入
+        # deque相比list的好处是，list的pop(0)是O(n)复杂度，deque的popleft()是O(1)复杂度
+
+        quene = deque([root])
+        out_list = []
+
+        while quene:
+            # 每次都取最后一个node就可以了
+            node = quene[-1]
+            out_list.append(node.val)
+
+            # 执行这个遍历的目的是获取下一层所有的node
+            for _ in range(len(quene)):
+                node = quene.popleft()
+                if node.left:
+                    quene.append(node.left)
+                if node.right:
+                    quene.append(node.right)
+        
+        return out_list
+    
+# 执行用时：36 ms, 在所有 Python3 提交中击败了89.47%的用户
+# 内存消耗：14.6 MB, 在所有 Python3 提交中击败了96.65%的用户
+```
+
+
+
+
+
 javascript代码:
 
 ```javascript
@@ -309,6 +390,46 @@ public:
 
 ```
 
+python代码：
+
+```python
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def averageOfLevels(self, root: TreeNode) -> List[float]:
+        if not root:
+            return []
+        
+        quene = deque([root])
+        out_list = []
+
+        while quene:
+            in_list = []
+
+            for _ in range(len(quene)):
+                node = quene.popleft()
+                in_list.append(node.val)
+                if node.left:
+                    quene.append(node.left)
+                if node.right:
+                    quene.append(node.right)
+
+            out_list.append(in_list)
+
+        out_list = map(lambda x: sum(x) / len(x), out_list)
+    
+        return out_list
+        
+# 执行用时：56 ms, 在所有 Python3 提交中击败了81.48%的用户
+# 内存消耗：17 MB, 在所有 Python3 提交中击败了89.68%的用户
+```
+
+
+
 javascript代码：
 
 ```javascript
@@ -385,7 +506,68 @@ public:
 };
 ```
 
+python代码：
+
+```python
+"""
+# Definition for a Node.
+class Node:
+    def __init__(self, val=None, children=None):
+        self.val = val
+        self.children = children
+"""
+
+class Solution:
+    def levelOrder(self, root: 'Node') -> List[List[int]]:
+        if not root:
+            return []
+        
+        quene = deque([root])
+        out_list = []
+
+        while quene:
+            in_list = []
+
+            for _ in range(len(quene)):
+                node = quene.popleft()
+                in_list.append(node.val)
+                if node.children:
+                    # 这个地方要用extend而不是append，我们看下面的例子：
+                    # In [18]: alist=[]
+                    # In [19]: alist.append([1,2,3])
+                    # In [20]: alist
+                    # Out[20]: [[1, 2, 3]]
+                    # In [21]: alist.extend([4,5,6])
+                    # In [22]: alist
+                    # Out[22]: [[1, 2, 3], 4, 5, 6]
+                    # 可以看到extend对要添加的list进行了一个解包操作
+                    # print(root.children)，可以得到children是一个包含
+                    # 孩子节点地址的list，我们使用for遍历quene的时候，
+                    # 希望quene是一个单层list，所以要用extend
+                    # 使用extend的情况，如果print(quene),结果是
+                    # deque([<__main__.Node object at 0x7f60763ae0a0>])
+				   # deque([<__main__.Node object at 0x7f607636e6d0>, <__main__.Node object at 0x7f607636e130>, <__main__.Node object at 0x7f607636e310>])
+				  # deque([<__main__.Node object at 0x7f607636e880>, <__main__.Node object at 0x7f607636ef10>])
+				  # 可以看到是单层list
+                    # 如果使用append，print(quene)的结果是
+                    # deque([<__main__.Node object at 0x7f18907530a0>])
+				  # deque([[<__main__.Node object at 0x7f18907136d0>, <__main__.Node object at 0x7f1890713130>, <__main__.Node object at 0x7f1890713310>]])
+				  # 可以看到是两层list，这样for的遍历就会报错
+                    
+                    quene.extend(node.children)
+                
+            out_list.append(in_list)
+        
+        return out_list
+    
+# 执行用时：60 ms, 在所有 Python3 提交中击败了76.99%的用户
+# 内存消耗：16.5 MB, 在所有 Python3 提交中击败了89.19%的用户
+```
+
+
+
 JavaScript代码：
+
 ```JavaScript
 var levelOrder = function(root) {
     //每一层可能有2个以上,所以不再使用node.left node.right