From 9617a8b3fedc3996645977df31104159864b3462 Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Mon, 1 May 2023 15:46:15 -0500
Subject: [PATCH 01/34] =?UTF-8?q?Update=200102.=E4=BA=8C=E5=8F=89=E6=A0=91?=
 =?UTF-8?q?=E7=9A=84=E5=B1=82=E5=BA=8F=E9=81=8D=E5=8E=86.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0102.二叉树的层序遍历.md | 75 +++++++++++++----------
 1 file changed, 44 insertions(+), 31 deletions(-)

diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index 26f0ae2d..e777c2a4 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -171,47 +171,60 @@ python3代码：
 
 
 ```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
+from collections import deque
 class Solution:
-    """二叉树层序遍历迭代解法"""
-
-    def levelOrder(self, root: TreeNode) -> List[List[int]]:
-        results = []
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
         if not root:
-            return results
-
-        from collections import deque
-        que = deque([root])
-
-        while que:
-            size = len(que)
-            result = []
-            for _ in range(size):
-                cur = que.popleft()
-                result.append(cur.val)
+            return []
+        queue = deque([root])
+        result = []
+        while queue:
+            level = []
+            for _ in range(len(queue)):
+                cur = queue.popleft()
+                level.append(cur.val)
                 if cur.left:
-                    que.append(cur.left)
+                    queue.append(cur.left)
                 if cur.right:
-                    que.append(cur.right)
-            results.append(result)
-
-        return results
+                    queue.append(cur.right)
+            result.append(level)
+        return result
 ```
-
 ```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 levelOrder(self, root: TreeNode) -> List[List[int]]:
-        res = []
-        def helper(root, depth):
-            if not root: return []
-            if len(res) == depth: res.append([]) # start the current depth
-            res[depth].append(root.val) # fulfil the current depth
-            if  root.left: helper(root.left, depth + 1) # process child nodes for the next depth
-            if  root.right: helper(root.right, depth + 1)
-        helper(root, 0)
-        return res
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        levels = []
+        self.helper(root, 0, levels)
+        return levels
+    
+    def helper(self, node, level, levels):
+        if not node:
+            return
+        if len(levels) == level:
+            levels.append([])
+        levels[level].append(node.val)
+        self.helper(node.left, level + 1, levels)
+        self.helper(node.right, level + 1, levels)
+
+
 ```
 
+
+
 go:
 
 ```go

From 424d5c224f229aaee353b3bbae8996b8e5dcbef2 Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Wed, 3 May 2023 15:06:11 -0500
Subject: [PATCH 02/34] =?UTF-8?q?Update=200027.=E7=A7=BB=E9=99=A4=E5=85=83?=
 =?UTF-8?q?=E7=B4=A0.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0027.移除元素.md | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/problems/0027.移除元素.md b/problems/0027.移除元素.md
index 91150c74..6dc6404e 100644
--- a/problems/0027.移除元素.md
+++ b/problems/0027.移除元素.md
@@ -198,6 +198,7 @@ Python：
 
 
 ``` python 3
+（版本一）快慢指针法
 class Solution:
     def removeElement(self, nums: List[int], val: int) -> int:
         # 快慢指针
@@ -213,7 +214,21 @@ class Solution:
         return slow
 ```
 
-
+``` python 3
+（版本二）暴力递归法
+class Solution:
+    def removeElement(self, nums: List[int], val: int) -> int:
+        i, l = 0, len(nums)
+        while i < l:
+            if nums[i] == val: # 找到等于目标值的节点
+                for j in range(i+1, l): # 移除该元素，并将后面元素向前平移
+                    nums[j - 1] = nums[j]
+                l -= 1
+                i -= 1
+            i += 1
+        return l
+                
+```
 
 
 Go：

From 53fbfc8339a6b61cb708ec87356e764db0f2b1ba Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Wed, 3 May 2023 15:08:17 -0500
Subject: [PATCH 03/34] =?UTF-8?q?Update=200027.=E7=A7=BB=E9=99=A4=E5=85=83?=
 =?UTF-8?q?=E7=B4=A0.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0027.移除元素.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/problems/0027.移除元素.md b/problems/0027.移除元素.md
index 6dc6404e..90801153 100644
--- a/problems/0027.移除元素.md
+++ b/problems/0027.移除元素.md
@@ -215,7 +215,7 @@ class Solution:
 ```
 
 ``` python 3
-（版本二）暴力递归法
+（版本二）暴力法
 class Solution:
     def removeElement(self, nums: List[int], val: int) -> int:
         i, l = 0, len(nums)

From 934dd4e3131485802edd5d7c45fd60dd4f8f2827 Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Wed, 3 May 2023 15:19:23 -0500
Subject: [PATCH 04/34] =?UTF-8?q?Update=200977.=E6=9C=89=E5=BA=8F=E6=95=B0?=
 =?UTF-8?q?=E7=BB=84=E7=9A=84=E5=B9=B3=E6=96=B9.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0977.有序数组的平方.md | 41 ++++++++++++++++++--------
 1 file changed, 28 insertions(+), 13 deletions(-)

diff --git a/problems/0977.有序数组的平方.md b/problems/0977.有序数组的平方.md
index 57f8de02..4fbdd1cd 100644
--- a/problems/0977.有序数组的平方.md
+++ b/problems/0977.有序数组的平方.md
@@ -140,22 +140,37 @@ class Solution {
 
 Python：
 ```Python
+（版本一）双指针法
 class Solution:
     def sortedSquares(self, nums: List[int]) -> List[int]:
-        n = len(nums)
-        i,j,k = 0,n - 1,n - 1
-        ans = [-1] * n
-        while i <= j:
-            lm = nums[i] ** 2
-            rm = nums[j] ** 2
-            if lm > rm:
-                ans[k] = lm
-                i += 1
+        l, r, i = 0, len(nums)-1, len(nums)-1
+        res = [float('inf')] * len(nums) # 需要提前定义列表，存放结果
+        while l <= r:
+            if nums[l] ** 2 < nums[r] ** 2: # 左右边界进行对比，找出最大值
+                res[i] = nums[r] ** 2
+                r -= 1 # 右指针往左移动
             else:
-                ans[k] = rm
-                j -= 1
-            k -= 1
-        return ans
+                res[i] = nums[l] ** 2
+                l += 1 # 左指针往右移动
+            i -= 1 # 存放结果的指针需要往前平移一位
+        return res
+```
+
+```Python
+（版本二）暴力排序法
+class Solution:
+    def sortedSquares(self, nums: List[int]) -> List[int]:
+        for i in range(len(nums)):
+            nums[i] *= nums[i]
+        nums.sort()
+        return nums
+```
+
+```Python
+（版本三）暴力排序法+列表推导法
+class Solution:
+    def sortedSquares(self, nums: List[int]) -> List[int]:
+        return sorted(x*x for x in nums)
 ```
 
 Go：

From 5f65e3ba24617dc81b199bcbb356f47517f7fbee Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Wed, 3 May 2023 15:32:36 -0500
Subject: [PATCH 05/34] =?UTF-8?q?Update=200209.=E9=95=BF=E5=BA=A6=E6=9C=80?=
 =?UTF-8?q?=E5=B0=8F=E7=9A=84=E5=AD=90=E6=95=B0=E7=BB=84.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0209.长度最小的子数组.md | 46 ++++++++++++++++++-----
 1 file changed, 36 insertions(+), 10 deletions(-)

diff --git a/problems/0209.长度最小的子数组.md b/problems/0209.长度最小的子数组.md
index 5a8f91af..d7ae4780 100644
--- a/problems/0209.长度最小的子数组.md
+++ b/problems/0209.长度最小的子数组.md
@@ -173,18 +173,44 @@ class Solution {
 Python：
 
 ```python
+（版本一）滑动窗口法
 class Solution:
     def minSubArrayLen(self, s: int, nums: List[int]) -> int:
-        res = float("inf")   # 定义一个无限大的数
-        Sum = 0     # 滑动窗口数值之和
-        i = 0      # 滑动窗口起始位置
-        for j in range(len(nums)):
-            Sum += nums[j]
-            while Sum >= s:
-                res = min(res, j-i+1)
-                Sum -= nums[i]
-                i += 1
-        return 0 if res == float("inf") else res
+        l = len(nums)
+        left = 0
+        right = 0
+        min_len = float('inf')
+        cur_sum = 0 #当前的累加值
+        
+        while right < l:
+            cur_sum += nums[right]
+            
+            while cur_sum >= s: # 当前累加值大于目标值
+                min_len = min(min_len, right - left + 1)
+                cur_sum -= nums[left]
+                left += 1
+            
+            right += 1
+        
+        return min_len if min_len != float('inf') else 0
+```
+
+```python
+（版本二）暴力法
+class Solution:
+    def minSubArrayLen(self, s: int, nums: List[int]) -> int:
+        l = len(nums)
+        min_len = float('inf')
+        
+        for i in range(l):
+            cur_sum = 0
+            for j in range(i, l):
+                cur_sum += nums[j]
+                if cur_sum >= s:
+                    min_len = min(min_len, j - i + 1)
+                    break
+        
+        return min_len if min_len != float('inf') else 0
 ```
 
 Go：

From f45b1f1d28a668e2c90ad66ac0d2141d59fc73ae Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Wed, 3 May 2023 16:19:13 -0500
Subject: [PATCH 06/34] =?UTF-8?q?Update=200203.=E7=A7=BB=E9=99=A4=E9=93=BE?=
 =?UTF-8?q?=E8=A1=A8=E5=85=83=E7=B4=A0.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0203.移除链表元素.md | 20 +++++++++++++-------
 1 file changed, 13 insertions(+), 7 deletions(-)

diff --git a/problems/0203.移除链表元素.md b/problems/0203.移除链表元素.md
index b52f16ea..6a0de282 100644
--- a/problems/0203.移除链表元素.md
+++ b/problems/0203.移除链表元素.md
@@ -307,21 +307,27 @@ public ListNode removeElements(ListNode head, int val) {
 Python：
 
 ```python
+（版本一）虚拟头节点法
 # Definition for singly-linked list.
 # class ListNode:
 #     def __init__(self, val=0, next=None):
 #         self.val = val
 #         self.next = next
 class Solution:
-    def removeElements(self, head: ListNode, val: int) -> ListNode:
-        dummy_head = ListNode(next=head) #添加一个虚拟节点
-        cur = dummy_head
-        while cur.next:
-            if cur.next.val == val:
-                cur.next = cur.next.next #删除cur.next节点
+    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
+        # 创建虚拟头部节点以简化删除过程
+        dummy_head = ListNode(next = head)
+        
+        # 遍历列表并删除值为val的节点
+        current = dummy_head
+        while current.next:
+            if current.next.val == val:
+                current.next = current.next.next
             else:
-                cur = cur.next
+                current = current.next
+        
         return dummy_head.next
+
 ```
 
 Go：

From 70d8379ff7fe99edbbd2d006b9b3d9a5068c66fc Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Wed, 3 May 2023 16:26:16 -0500
Subject: [PATCH 07/34] =?UTF-8?q?Update=200707.=E8=AE=BE=E8=AE=A1=E9=93=BE?=
 =?UTF-8?q?=E8=A1=A8.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0707.设计链表.md | 294 +++++++++++++++++-----------------
 1 file changed, 144 insertions(+), 150 deletions(-)

diff --git a/problems/0707.设计链表.md b/problems/0707.设计链表.md
index c72b7327..aa04d0e1 100644
--- a/problems/0707.设计链表.md
+++ b/problems/0707.设计链表.md
@@ -485,172 +485,166 @@ class MyLinkedList {
 
 Python：
 ```python
-# 单链表
-class MyLinkedList1:
-
-    def __init__(self):
-        self.dummy_head = Node()# 添加虚拟头指针，便于操作
-        self.size = 0 # 设置一个链表长度的属性，便于后续操作，注意每次增和删的时候都要更新
-
-    def get(self, index):
-        """
-        :type index: int
-        :rtype: int
-        """
-        if index < 0 or index >= self.size:
-            return -1
-        cur = self.dummy_head.next
-        while(index):
-            cur = cur.next
-            index -= 1
-        return cur.val
-
-    def addAtHead(self, val):
-        """
-        :type val: int
-        :rtype: None
-        """
-        new_node = Node(val)
-        new_node.next = self.dummy_head.next
-        self.dummy_head.next = new_node
-        self.size += 1
-
-    def addAtTail(self, val):
-        """
-        :type val: int
-        :rtype: None
-        """
-        new_node = Node(val)
-        cur = self.dummy_head
-        while(cur.next):
-            cur = cur.next
-        cur.next = new_node
-        self.size += 1
-
-    def addAtIndex(self, index, val):
-        """
-        :type index: int
-        :type val: int
-        :rtype: None
-        """
-        if index < 0:
-            self.addAtHead(val)
-            return
-        elif index == self.size:
-            self.addAtTail(val)
-            return
-        elif index > self.size:
-            return
-
-        node = Node(val)
-        cur = self.dummy_head
-        while(index):
-            cur = cur.next
-            index -= 1
-        node.next = cur.next
-        cur.next = node
-        self.size += 1
-        
-    def deleteAtIndex(self, index):
-        """
-        :type index: int
-        :rtype: None
-        """
-        if index < 0 or index >= self.size:
-            return
-        pre = self.dummy_head
-        while(index):
-            pre = pre.next
-            index -= 1
-        pre.next = pre.next.next
-        self.size -= 1
-	
-# 双链表
-# 相对于单链表, Node新增了prev属性
-class Node:
-    
-    def __init__(self, val=0, next = None, prev = None):
+（版本一）单链表法
+class ListNode:
+    def __init__(self, val=0, next=None):
         self.val = val
         self.next = next
-        self.prev = prev
-
+        
 class MyLinkedList:
-
     def __init__(self):
-        self._head, self._tail = Node(0), Node(0)  # 虚拟节点
-        self._head.next, self._tail.prev = self._tail, self._head
-        self._count = 0  # 添加的节点数
-
-    def _get_node(self, index: int) -> Node:
-        # 当index小于_count//2时, 使用_head查找更快, 反之_tail更快
-        if index >= self._count // 2:
-            # 使用prev往前找
-            node = self._tail
-            for _ in range(self._count - index):
-                node = node.prev
-        else:
-            # 使用next往后找
-            node = self._head   
-            for _ in range(index + 1):
-                node = node.next
-        return node
-
-
-    def _update(self, prev: Node, next: Node, val: int) -> None:
-        """
-            更新节点
-            :param prev: 相对于更新的前一个节点
-            :param next: 相对于更新的后一个节点
-            :param val:  要添加的节点值
-        """
-        # 计数累加
-        self._count += 1
-        node = Node(val)
-        prev.next, next.prev = node, node
-        node.prev, node.next = prev, next
+        self.dummy_head = ListNode()
+        self.size = 0
 
     def get(self, index: int) -> int:
-        """
-        Get the value of the index-th node in the linked list. If the index is invalid, return -1.
-        """
-        if 0 <= index < self._count:
-            node = self._get_node(index)
-            return node.val
-        else:
+        if index < 0 or index >= self.size:
             return -1
+        
+        current = self.dummy_head.next
+        for i in range(index):
+            current = current.next
+            
+        return current.val
 
     def addAtHead(self, val: int) -> None:
-        """
-        Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list.
-        """
-        self._update(self._head, self._head.next, val)
+        self.dummy_head.next = ListNode(val, self.dummy_head.next)
+        self.size += 1
 
     def addAtTail(self, val: int) -> None:
-        """
-        Append a node of value val to the last element of the linked list.
-        """
-        self._update(self._tail.prev, self._tail, val)
+        current = self.dummy_head
+        while current.next:
+            current = current.next
+        current.next = ListNode(val)
+        self.size += 1
 
     def addAtIndex(self, index: int, val: int) -> None:
-        """
-        Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted.
-        """
-        if index < 0:
-            index = 0
-        elif index > self._count:
+        if index < 0 or index > self.size:
             return
-        node = self._get_node(index)
-        self._update(node.prev, node, val)
+        
+        current = self.dummy_head
+        for i in range(index):
+            current = current.next
+        current.next = ListNode(val, current.next)
+        self.size += 1
 
     def deleteAtIndex(self, index: int) -> None:
-        """
-        Delete the index-th node in the linked list, if the index is valid.
-        """
-        if 0 <= index < self._count:
-            node = self._get_node(index)
-            # 计数-1
-            self._count -= 1
-            node.prev.next, node.next.prev = node.next, node.prev
+        if index < 0 or index >= self.size:
+            return
+        
+        current = self.dummy_head
+        for i in range(index):
+            current = current.next
+        current.next = current.next.next
+        self.size -= 1
+
+
+# Your MyLinkedList object will be instantiated and called as such:
+# obj = MyLinkedList()
+# param_1 = obj.get(index)
+# obj.addAtHead(val)
+# obj.addAtTail(val)
+# obj.addAtIndex(index,val)
+# obj.deleteAtIndex(index)
+```
+
+
+```python
+（版本二）双链表法
+class ListNode:
+    def __init__(self, val=0, prev=None, next=None):
+        self.val = val
+        self.prev = prev
+        self.next = next
+
+class MyLinkedList:
+    def __init__(self):
+        self.head = None
+        self.tail = None
+        self.size = 0
+
+    def get(self, index: int) -> int:
+        if index < 0 or index >= self.size:
+            return -1
+        
+        if index < self.size // 2:
+            current = self.head
+            for i in range(index):
+                current = current.next
+        else:
+            current = self.tail
+            for i in range(self.size - index - 1):
+                current = current.prev
+                
+        return current.val
+
+    def addAtHead(self, val: int) -> None:
+        new_node = ListNode(val, None, self.head)
+        if self.head:
+            self.head.prev = new_node
+        else:
+            self.tail = new_node
+        self.head = new_node
+        self.size += 1
+
+    def addAtTail(self, val: int) -> None:
+        new_node = ListNode(val, self.tail, None)
+        if self.tail:
+            self.tail.next = new_node
+        else:
+            self.head = new_node
+        self.tail = new_node
+        self.size += 1
+
+    def addAtIndex(self, index: int, val: int) -> None:
+        if index < 0 or index > self.size:
+            return
+        
+        if index == 0:
+            self.addAtHead(val)
+        elif index == self.size:
+            self.addAtTail(val)
+        else:
+            if index < self.size // 2:
+                current = self.head
+                for i in range(index - 1):
+                    current = current.next
+            else:
+                current = self.tail
+                for i in range(self.size - index):
+                    current = current.prev
+            new_node = ListNode(val, current, current.next)
+            current.next.prev = new_node
+            current.next = new_node
+            self.size += 1
+
+    def deleteAtIndex(self, index: int) -> None:
+        if index < 0 or index >= self.size:
+            return
+        
+        if index == 0:
+            self.head = self.head.next
+            if self.head:
+                self.head.prev = None
+            else:
+                self.tail = None
+        elif index == self.size - 1:
+            self.tail = self.tail.prev
+            if self.tail:
+                self.tail.next = None
+            else:
+                self.head = None
+        else:
+            if index < self.size // 2:
+                current = self.head
+                for i in range(index):
+                    current = current.next
+            else:
+                current = self.tail
+                for i in range(self.size - index - 1):
+                    current = current.prev
+            current.prev.next = current.next
+            current.next.prev = current.prev
+        self.size -= 1
 
 
 

From 55ea26c5bdac70997c6ad9833448cdf3c1a7e0d1 Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Wed, 3 May 2023 17:18:48 -0500
Subject: [PATCH 08/34] =?UTF-8?q?Update=200206.=E7=BF=BB=E8=BD=AC=E9=93=BE?=
 =?UTF-8?q?=E8=A1=A8.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0206.翻转链表.md | 40 ++++++++++-------------------------
 1 file changed, 11 insertions(+), 29 deletions(-)

diff --git a/problems/0206.翻转链表.md b/problems/0206.翻转链表.md
index d558e783..0425e182 100644
--- a/problems/0206.翻转链表.md
+++ b/problems/0206.翻转链表.md
@@ -193,9 +193,9 @@ class Solution {
 }
 ```
 
-Python迭代法：
+Python
 ```python
-#双指针
+（版本一）双指针法
 # Definition for singly-linked list.
 # class ListNode:
 #     def __init__(self, val=0, next=None):
@@ -205,7 +205,7 @@ class Solution:
     def reverseList(self, head: ListNode) -> ListNode:
         cur = head   
         pre = None
-        while(cur!=None):
+        while cur:
             temp = cur.next # 保存一下 cur的下一个节点，因为接下来要改变cur->next
             cur.next = pre #反转
             #更新pre、cur指针
@@ -217,6 +217,7 @@ class Solution:
 Python递归法：
 
 ```python
+（版本二）递归法
 # Definition for singly-linked list.
 # class ListNode:
 #     def __init__(self, val=0, next=None):
@@ -224,36 +225,17 @@ Python递归法：
 #         self.next = next
 class Solution:
     def reverseList(self, head: ListNode) -> ListNode:
-        
-        def reverse(pre,cur):
-            if not cur:
-                return pre
-                
-            tmp = cur.next
-            cur.next = pre
-
-            return reverse(cur,tmp)
-        
-        return reverse(None,head)
+        return self.reverse(head, None)
+    def reverse(self, cur: ListNode, pre: ListNode) -> ListNode:
+        if cur == None:
+            return pre
+        temp = cur.next
+        cur.next = pre
+        return self.reverse(temp, cur)
 
 ```
 
-Python递归法从后向前：
 
-```python
-# Definition for singly-linked list.
-# class ListNode:
-#     def __init__(self, val=0, next=None):
-#         self.val = val
-#         self.next = next
-class Solution:
-    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
-        if not head or not head.next: return head
-        p = self.reverseList(head.next)
-        head.next.next = head
-        head.next = None
-        return p
-```
 
 Go：
 

From d92104209fecd89626df38414d03c78371f251e5 Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Wed, 3 May 2023 17:20:34 -0500
Subject: [PATCH 09/34] =?UTF-8?q?Update=200024.=E4=B8=A4=E4=B8=A4=E4=BA=A4?=
 =?UTF-8?q?=E6=8D=A2=E9=93=BE=E8=A1=A8=E4=B8=AD=E7=9A=84=E8=8A=82=E7=82=B9?=
 =?UTF-8?q?.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../0024.两两交换链表中的节点.md    | 23 +++++++++----------
 1 file changed, 11 insertions(+), 12 deletions(-)

diff --git a/problems/0024.两两交换链表中的节点.md b/problems/0024.两两交换链表中的节点.md
index 4dc051aa..2c171dde 100644
--- a/problems/0024.两两交换链表中的节点.md
+++ b/problems/0024.两两交换链表中的节点.md
@@ -186,21 +186,20 @@ Python：
 
 class Solution:
     def swapPairs(self, head: ListNode) -> ListNode:
-        res = ListNode(next=head)
-        pre = res
+        dummy_head = ListNode(next=head)
+        current = dummy_head
         
-        # 必须有pre的下一个和下下个才能交换，否则说明已经交换结束了
-        while pre.next and pre.next.next:
-            cur = pre.next
-            post = pre.next.next
+        # 必须有cur的下一个和下下个才能交换，否则说明已经交换结束了
+        while current.next and current.next.next:
+            temp = current.next # 防止节点修改
+            temp1 = current.next.next.next
             
-            # pre，cur，post对应最左，中间的，最右边的节点
-            cur.next = post.next
-            post.next = cur
-            pre.next = post
+            current.next = current.next.next
+            current.next.next = temp
+            temp.next = temp1
+            current = current.next.next
+        return dummy_head.next
 
-            pre = pre.next.next
-        return res.next
 ```
 
 Go：

From 190477400ebf0842343588c4e9e15c5eab412eb4 Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Wed, 3 May 2023 17:22:46 -0500
Subject: [PATCH 10/34] =?UTF-8?q?Update=200019.=E5=88=A0=E9=99=A4=E9=93=BE?=
 =?UTF-8?q?=E8=A1=A8=E7=9A=84=E5=80=92=E6=95=B0=E7=AC=ACN=E4=B8=AA?=
 =?UTF-8?q?=E8=8A=82=E7=82=B9.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...0019.删除链表的倒数第N个节点.md | 28 ++++++++++++-------
 1 file changed, 18 insertions(+), 10 deletions(-)

diff --git a/problems/0019.删除链表的倒数第N个节点.md b/problems/0019.删除链表的倒数第N个节点.md
index a11ff8ba..c6f5bfc7 100644
--- a/problems/0019.删除链表的倒数第N个节点.md
+++ b/problems/0019.删除链表的倒数第N个节点.md
@@ -127,21 +127,29 @@ Python:
 #     def __init__(self, val=0, next=None):
 #         self.val = val
 #         self.next = next
+
 class Solution:
     def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
-        head_dummy = ListNode()
-        head_dummy.next = head
-
-        slow, fast = head_dummy, head_dummy
-        while(n>=0): #fast先往前走n+1步
+        # 创建一个虚拟节点，并将其下一个指针设置为链表的头部
+        dummy_head = ListNode(0, head)
+        
+        # 创建两个指针，慢指针和快指针，并将它们初始化为虚拟节点
+        slow = fast = dummy_head
+        
+        # 快指针比慢指针快 n+1 步
+        for i in range(n+1):
             fast = fast.next
-            n -= 1
-        while(fast!=None):
+        
+        # 移动两个指针，直到快速指针到达链表的末尾
+        while fast:
             slow = slow.next
             fast = fast.next
-        #fast 走到结尾后，slow的下一个节点为倒数第N个节点
-        slow.next = slow.next.next #删除
-        return head_dummy.next
+        
+        # 通过更新第 (n-1) 个节点的 next 指针删除第 n 个节点
+        slow.next = slow.next.next
+        
+        return dummy_head.next
+
 ```
 Go:
 ```Go

From e4072d9a00b12c6de6949091378bdd8d95b5296c Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Wed, 3 May 2023 17:25:36 -0500
Subject: [PATCH 11/34] =?UTF-8?q?Update=20=E9=9D=A2=E8=AF=95=E9=A2=9802.07?=
 =?UTF-8?q?.=E9=93=BE=E8=A1=A8=E7=9B=B8=E4=BA=A4.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/面试题02.07.链表相交.md | 63 ++++++++++++++++++++++++-
 1 file changed, 62 insertions(+), 1 deletion(-)

diff --git a/problems/面试题02.07.链表相交.md b/problems/面试题02.07.链表相交.md
index 30f5c467..4bcbd1f9 100644
--- a/problems/面试题02.07.链表相交.md
+++ b/problems/面试题02.07.链表相交.md
@@ -152,7 +152,7 @@ public class Solution {
 
 ### Python
 ```python
-
+（版本一）求长度，同时出发
 class Solution:
     def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
         lenA, lenB = 0, 0
@@ -178,7 +178,68 @@ class Solution:
                 curB = curB.next
         return None 
 ```
+```python
+（版本二）求长度，同时出发 （代码复用）
+class Solution:
+    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
+        lenA = self.getLength(headA)
+        lenB = self.getLength(headB)
+        
+        # 通过移动较长的链表，使两链表长度相等
+        if lenA > lenB:
+            headA = self.moveForward(headA, lenA - lenB)
+        else:
+            headB = self.moveForward(headB, lenB - lenA)
+        
+        # 将两个头向前移动，直到它们相交
+        while headA and headB:
+            if headA == headB:
+                return headA
+            headA = headA.next
+            headB = headB.next
+        
+        return None
+    
+    def getLength(self, head: ListNode) -> int:
+        length = 0
+        while head:
+            length += 1
+            head = head.next
+        return length
+    
+    def moveForward(self, head: ListNode, steps: int) -> ListNode:
+        while steps > 0:
+            head = head.next
+            steps -= 1
+        return head
+```
+```python
+（版本三）等比例法
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
 
+class Solution:
+    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
+        # 处理边缘情况
+        if not headA or not headB:
+            return None
+        
+        # 在每个链表的头部初始化两个指针
+        pointerA = headA
+        pointerB = headB
+        
+        # 遍历两个链表直到指针相交
+        while pointerA != pointerB:
+            # 将指针向前移动一个节点
+            pointerA = pointerA.next if pointerA else headB
+            pointerB = pointerB.next if pointerB else headA
+        
+        # 如果相交，指针将位于交点节点，如果没有交点，值为None
+        return pointerA
+```
 ### Go
 
 ```go

From b2bfb8016642f388389250df57bad7e9cce82a3f Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Wed, 3 May 2023 17:27:27 -0500
Subject: [PATCH 12/34] =?UTF-8?q?Update=200142.=E7=8E=AF=E5=BD=A2=E9=93=BE?=
 =?UTF-8?q?=E8=A1=A8II.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0142.环形链表II.md | 50 ++++++++++++++++++++++++++-------
 1 file changed, 40 insertions(+), 10 deletions(-)

diff --git a/problems/0142.环形链表II.md b/problems/0142.环形链表II.md
index 46df4777..e80a715a 100644
--- a/problems/0142.环形链表II.md
+++ b/problems/0142.环形链表II.md
@@ -221,25 +221,55 @@ public class Solution {
 Python：
 
 ```python
+（版本一）快慢指针法
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+
 class Solution:
     def detectCycle(self, head: ListNode) -> ListNode:
-        slow, fast = head, head
+        slow = head
+        fast = head
+        
         while fast and fast.next:
             slow = slow.next
             fast = fast.next.next
-            # 如果相遇
+            
+            # If there is a cycle, the slow and fast pointers will eventually meet
             if slow == fast:
-                p = head
-                q = slow
-                while p!=q:
-                    p = p.next
-                    q = q.next
-                #你也可以return q
-                return p
-
+                # Move one of the pointers back to the start of the list
+                slow = head
+                while slow != fast:
+                    slow = slow.next
+                    fast = fast.next
+                return slow
+        # If there is no cycle, return None
         return None
 ```
+```python
+（版本二）集合法
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
 
+
+class Solution:
+    def detectCycle(self, head: ListNode) -> ListNode:
+        visited = set()
+        
+        while head:
+            if head in visited:
+                return head
+            visited.add(head)
+            head = head.next
+        
+        return None
+```
 Go：
 
 ```go

From dd58553088514af1a1a019fb9e6d4b2e41b0aeb5 Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Wed, 3 May 2023 19:26:39 -0500
Subject: [PATCH 13/34] =?UTF-8?q?Update=20=E4=BA=8C=E5=8F=89=E6=A0=91?=
 =?UTF-8?q?=E7=9A=84=E9=80=92=E5=BD=92=E9=81=8D=E5=8E=86.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/二叉树的递归遍历.md | 53 +++++++++++++---------------
 1 file changed, 24 insertions(+), 29 deletions(-)

diff --git a/problems/二叉树的递归遍历.md b/problems/二叉树的递归遍历.md
index 5a9a670a..8d5a5985 100644
--- a/problems/二叉树的递归遍历.md
+++ b/problems/二叉树的递归遍历.md
@@ -174,50 +174,45 @@ class Solution {
 Python：
 ```python
 # 前序遍历-递归-LC144_二叉树的前序遍历
+# 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 preorderTraversal(self, root: TreeNode) -> List[int]:
-        # 保存结果
-        result = []
-        
-        def traversal(root: TreeNode):
-            if root == None:
-                return
-            result.append(root.val) # 前序
-            traversal(root.left)    # 左
-            traversal(root.right)   # 右
+        if not root:
+            return []
+
+        left = self.preorderTraversal(root.left)
+        right = self.preorderTraversal(root.right)
+
+        return  [root.val] + left +  right
 
-        traversal(root)
-        return result
 
 # 中序遍历-递归-LC94_二叉树的中序遍历
 class Solution:
     def inorderTraversal(self, root: TreeNode) -> List[int]:
-        result = []
+        if root is None:
+            return []
 
-        def traversal(root: TreeNode):
-            if root == None:
-                return
-            traversal(root.left)    # 左
-            result.append(root.val) # 中序
-            traversal(root.right)   # 右
+        left = self.inorderTraversal(root.left)
+        right = self.inorderTraversal(root.right)
 
-        traversal(root)
-        return result
+        return left + [root.val] + right
 
 # 后序遍历-递归-LC145_二叉树的后序遍历
 class Solution:
     def postorderTraversal(self, root: TreeNode) -> List[int]:
-        result = []
+        if not root:
+            return []
 
-        def traversal(root: TreeNode):
-            if root == None:
-                return
-            traversal(root.left)    # 左
-            traversal(root.right)   # 右
-            result.append(root.val) # 后序
+        left = self.postorderTraversal(root.left)
+        right = self.postorderTraversal(root.right)
 
-        traversal(root)
-        return result
+        return left + right + [root.val]
 ```
 
 Go：

From dd1da7fc548c7ab7c1e0964f0ef50410be53e551 Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Wed, 3 May 2023 19:27:58 -0500
Subject: [PATCH 14/34] =?UTF-8?q?Update=20=E4=BA=8C=E5=8F=89=E6=A0=91?=
 =?UTF-8?q?=E7=9A=84=E9=80=92=E5=BD=92=E9=81=8D=E5=8E=86.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/二叉树的递归遍历.md | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/problems/二叉树的递归遍历.md b/problems/二叉树的递归遍历.md
index 8d5a5985..92f342f0 100644
--- a/problems/二叉树的递归遍历.md
+++ b/problems/二叉树的递归遍历.md
@@ -191,7 +191,8 @@ class Solution:
 
         return  [root.val] + left +  right
 
-
+```
+```python
 # 中序遍历-递归-LC94_二叉树的中序遍历
 class Solution:
     def inorderTraversal(self, root: TreeNode) -> List[int]:
@@ -202,6 +203,9 @@ class Solution:
         right = self.inorderTraversal(root.right)
 
         return left + [root.val] + right
+```
+```python
+
 
 # 后序遍历-递归-LC145_二叉树的后序遍历
 class Solution:

From ce5b335b7258b7febb2dc831d68bfd3bb6161905 Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Wed, 3 May 2023 19:30:53 -0500
Subject: [PATCH 15/34] =?UTF-8?q?Update=20=E4=BA=8C=E5=8F=89=E6=A0=91?=
 =?UTF-8?q?=E7=9A=84=E8=BF=AD=E4=BB=A3=E9=81=8D=E5=8E=86.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/二叉树的迭代遍历.md | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/problems/二叉树的迭代遍历.md b/problems/二叉树的迭代遍历.md
index 35cf4077..8b241465 100644
--- a/problems/二叉树的迭代遍历.md
+++ b/problems/二叉树的迭代遍历.md
@@ -258,7 +258,9 @@ class Solution:
             if node.left:
                 stack.append(node.left)
         return result
-        
+```
+```python
+
 # 中序遍历-迭代-LC94_二叉树的中序遍历
 class Solution:
     def inorderTraversal(self, root: TreeNode) -> List[int]:
@@ -279,7 +281,9 @@ class Solution:
                 # 取栈顶元素右结点
                 cur = cur.right	
         return result
-        
+ ```
+ ```python
+
 # 后序遍历-迭代-LC145_二叉树的后序遍历
 class Solution:
     def postorderTraversal(self, root: TreeNode) -> List[int]:

From 0521f762d90b1af39fa4f134d219e2d208988e3b Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Wed, 3 May 2023 19:48:57 -0500
Subject: [PATCH 16/34] =?UTF-8?q?Update=200102.=E4=BA=8C=E5=8F=89=E6=A0=91?=
 =?UTF-8?q?=E7=9A=84=E5=B1=82=E5=BA=8F=E9=81=8D=E5=8E=86.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0102.二叉树的层序遍历.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index e777c2a4..29deee11 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -178,12 +178,11 @@ python3代码：
 #         self.val = val
 #         self.left = left
 #         self.right = right
-from collections import deque
 class Solution:
     def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
         if not root:
             return []
-        queue = deque([root])
+        queue = collections.deque([root])
         result = []
         while queue:
             level = []

From 42f85c8a8f8c637dbb484ca0d0c9ab88973c3a0b Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Wed, 3 May 2023 19:56:26 -0500
Subject: [PATCH 17/34] =?UTF-8?q?Update=200102.=E4=BA=8C=E5=8F=89=E6=A0=91?=
 =?UTF-8?q?=E7=9A=84=E5=B1=82=E5=BA=8F=E9=81=8D=E5=8E=86.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0102.二叉树的层序遍历.md | 36 ++++++++++++-----------
 1 file changed, 19 insertions(+), 17 deletions(-)

diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index 29deee11..a4164b2c 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -512,27 +512,29 @@ python代码：
 class Solution:
     """二叉树层序遍历II迭代解法"""
 
+# 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]]:
-        results = []
         if not root:
-            return results
-
-        from collections import deque
-        que = deque([root])
-
-        while que:
-            result = []
-            for _ in range(len(que)):
-                cur = que.popleft()
-                result.append(cur.val)
+            return []
+        queue = collections.deque([root])
+        result = []
+        while queue:
+            level = []
+            for _ in range(len(queue)):
+                cur = queue.popleft()
+                level.append(cur.val)
                 if cur.left:
-                    que.append(cur.left)
+                    queue.append(cur.left)
                 if cur.right:
-                    que.append(cur.right)
-            results.append(result)
-
-        results.reverse()
-        return results
+                    queue.append(cur.right)
+            result.append(level)
+        return result[::-1]
 ```
 
 Java：

From 52092d0153828a14179b41d041e99121a9b4f1f2 Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Wed, 3 May 2023 20:01:07 -0500
Subject: [PATCH 18/34] =?UTF-8?q?Update=200102.=E4=BA=8C=E5=8F=89=E6=A0=91?=
 =?UTF-8?q?=E7=9A=84=E5=B1=82=E5=BA=8F=E9=81=8D=E5=8E=86.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0102.二叉树的层序遍历.md | 46 +++++++++++------------
 1 file changed, 23 insertions(+), 23 deletions(-)

diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index a4164b2c..fdfde822 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -835,35 +835,35 @@ 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()
+        
+        queue = collections.deque([root])
+        right_view = []
+        
+        while queue:
+            level_size = len(queue)
+            
+            for i in range(level_size):
+                node = queue.popleft()
+                
+                if i == level_size - 1:
+                    right_view.append(node.val)
+                
                 if node.left:
-                    quene.append(node.left)
+                    queue.append(node.left)
                 if node.right:
-                    quene.append(node.right)
-
-        return out_list
-
-# 执行用时：36 ms, 在所有 Python3 提交中击败了89.47%的用户
-# 内存消耗：14.6 MB, 在所有 Python3 提交中击败了96.65%的用户
+                    queue.append(node.right)
+        
+        return right_view
 ```
 
 

From 95616fa9a8a147f3255ead5523af0a4de51844b9 Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Wed, 3 May 2023 20:03:09 -0500
Subject: [PATCH 19/34] =?UTF-8?q?Update=200102.=E4=BA=8C=E5=8F=89=E6=A0=91?=
 =?UTF-8?q?=E7=9A=84=E5=B1=82=E5=BA=8F=E9=81=8D=E5=8E=86.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0102.二叉树的层序遍历.md | 47 ++++++++++++++---------
 1 file changed, 29 insertions(+), 18 deletions(-)

diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index fdfde822..f4a5c466 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -1121,27 +1121,38 @@ python代码：
 class Solution:
     """二叉树层平均值迭代解法"""
 
+# 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]:
-        results = []
         if not root:
-            return results
+            return []
 
-        from collections import deque
-        que = deque([root])
-
-        while que:
-            size = len(que)
-            sum_ = 0
-            for _ in range(size):
-                cur = que.popleft()
-                sum_ += cur.val
-                if cur.left:
-                    que.append(cur.left)
-                if cur.right:
-                    que.append(cur.right)
-            results.append(sum_ / size)
-
-        return results
+        queue = collections.deque([root])
+        averages = []
+        
+        while queue:
+            size = len(queue)
+            level_sum = 0
+            
+            for i in range(size):
+                node = queue.popleft()
+                
+                
+                level_sum += node.val
+                    
+                if node.left:
+                    queue.append(node.left)
+                if node.right:
+                    queue.append(node.right)
+            
+            averages.append(level_sum / size)
+        
+        return averages
 ```
 
 java:

From 7be18e2dd372a17288c8cb215b52dc5a06c1a240 Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Wed, 3 May 2023 20:04:54 -0500
Subject: [PATCH 20/34] =?UTF-8?q?Update=200102.=E4=BA=8C=E5=8F=89=E6=A0=91?=
 =?UTF-8?q?=E7=9A=84=E5=B1=82=E5=BA=8F=E9=81=8D=E5=8E=86.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0102.二叉树的层序遍历.md | 40 ++++++++++++++---------
 1 file changed, 24 insertions(+), 16 deletions(-)

diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index f4a5c466..ed2c683d 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -1426,28 +1426,36 @@ public:
 python代码：
 
 ```python
+"""
+# Definition for a Node.
+class Node:
+    def __init__(self, val=None, children=None):
+        self.val = val
+        self.children = children
+"""
+
 class Solution:
-    """N叉树的层序遍历迭代法"""
-
     def levelOrder(self, root: 'Node') -> List[List[int]]:
-        results = []
         if not root:
-            return results
+            return []
 
-        from collections import deque
-        que = deque([root])
+        result = []
+        queue = collections.deque([root])
 
-        while que:
-            result = []
-            for _ in range(len(que)):
-                cur = que.popleft()
-                result.append(cur.val)
-                # cur.children 是 Node 对象组成的列表，也可能为 None
-                if cur.children:
-                    que.extend(cur.children)
-            results.append(result)
+        while queue:
+            level_size = len(queue)
+            level = []
 
-        return results
+            for _ in range(level_size):
+                node = queue.popleft()
+                level.append(node.val)
+
+                for child in node.children:
+                    queue.append(child)
+
+            result.append(level)
+
+        return result
 ```
 
 ```python

From 994db141aa831866a5551d7c01c5d676252b9876 Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Wed, 3 May 2023 20:06:39 -0500
Subject: [PATCH 21/34] =?UTF-8?q?Update=200102.=E4=BA=8C=E5=8F=89=E6=A0=91?=
 =?UTF-8?q?=E7=9A=84=E5=B1=82=E5=BA=8F=E9=81=8D=E5=8E=86.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0102.二叉树的层序遍历.md | 39 ++++++++++++++++-------
 1 file changed, 27 insertions(+), 12 deletions(-)

diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index ed2c683d..6235ad21 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -1761,22 +1761,37 @@ 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 largestValues(self, root: TreeNode) -> List[int]:
-        if root is None:
+        if not root:
             return []
-        queue = [root]
-        out_list = []
+
+        result = []
+        queue = collections.deque([root])
+
         while queue:
-            length = len(queue)
-            in_list = []
-            for _ in range(length):
-                curnode = queue.pop(0)
-                in_list.append(curnode.val)
-                if curnode.left: queue.append(curnode.left)
-                if curnode.right: queue.append(curnode.right)
-            out_list.append(max(in_list))
-        return out_list
+            level_size = len(queue)
+            max_val = float('-inf')
+
+            for _ in range(level_size):
+                node = queue.popleft()
+                max_val = max(max_val, node.val)
+
+                if node.left:
+                    queue.append(node.left)
+
+                if node.right:
+                    queue.append(node.right)
+
+            result.append(max_val)
+
+        return result
 ```
 
 java代码：

From ffab57f2c330f35a624bd7c9ce7dc9d444f0ff79 Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Wed, 3 May 2023 20:09:12 -0500
Subject: [PATCH 22/34] =?UTF-8?q?Update=200102.=E4=BA=8C=E5=8F=89=E6=A0=91?=
 =?UTF-8?q?=E7=9A=84=E5=B1=82=E5=BA=8F=E9=81=8D=E5=8E=86.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0102.二叉树的层序遍历.md | 48 ++++++++++++-----------
 1 file changed, 26 insertions(+), 22 deletions(-)

diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index 6235ad21..47969b25 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -2096,36 +2096,40 @@ class Solution {
 python代码：
 
 ```python
-# 层序遍历解法
+"""
+# Definition for a Node.
+class Node:
+    def __init__(self, val: int = 0, left: 'Node' = None, right: 'Node' = None, next: 'Node' = None):
+        self.val = val
+        self.left = left
+        self.right = right
+        self.next = next
+"""
 class Solution:
     def connect(self, root: 'Node') -> 'Node':
         if not root:
-            return None
-        queue = [root]
+            return root
+        
+        queue = collections.deque([root])
+        
         while queue:
-            n = len(queue)
-            for i in range(n):
-                node = queue.pop(0)
+            level_size = len(queue)
+            prev = None
+            
+            for i in range(level_size):
+                node = queue.popleft()
+                
+                if prev:
+                    prev.next = node
+                
+                prev = node
+                
                 if node.left:
                     queue.append(node.left)
+                
                 if node.right:
                     queue.append(node.right)
-                if i == n - 1:
-                    break
-                node.next = queue[0]
-        return root
-
-# 链表解法
-class Solution:
-    def connect(self, root: 'Node') -> 'Node':
-        first = root
-        while first:
-            cur = first
-            while cur:  # 遍历每一层的节点
-                if cur.left: cur.left.next = cur.right  # 找左节点的next
-                if cur.right and cur.next: cur.right.next = cur.next.left  # 找右节点的next
-                cur = cur.next # cur同层移动到下一节点
-            first = first.left  # 从本层扩展到下一层
+        
         return root
 ```
 

From 65085c4e9bcf8c478fe67caad7dd0dceaa5911e0 Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Wed, 3 May 2023 20:10:51 -0500
Subject: [PATCH 23/34] =?UTF-8?q?Update=200102.=E4=BA=8C=E5=8F=89=E6=A0=91?=
 =?UTF-8?q?=E7=9A=84=E5=B1=82=E5=BA=8F=E9=81=8D=E5=8E=86.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0102.二叉树的层序遍历.md | 44 ++++++++++++++++-------
 1 file changed, 32 insertions(+), 12 deletions(-)

diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index 47969b25..89e7a126 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -2381,21 +2381,41 @@ python代码：
 
 ```python
 # 层序遍历解法
+"""
+# Definition for a Node.
+class Node:
+    def __init__(self, val: int = 0, left: 'Node' = None, right: 'Node' = None, next: 'Node' = None):
+        self.val = val
+        self.left = left
+        self.right = right
+        self.next = next
+"""
+
 class Solution:
     def connect(self, root: 'Node') -> 'Node':
         if not root:
-            return None
-        queue = [root]
-        while queue:  # 遍历每一层
-            length = len(queue)
-            tail = None # 每一层维护一个尾节点
-            for i in range(length): # 遍历当前层
-                curnode = queue.pop(0)
-                if tail:
-                    tail.next = curnode # 让尾节点指向当前节点
-                tail = curnode # 让当前节点成为尾节点
-                if curnode.left : queue.append(curnode.left)
-                if curnode.right: queue.append(curnode.right)
+            return root
+        
+        queue = collections.deque([root])
+        
+        while queue:
+            level_size = len(queue)
+            prev = None
+            
+            for i in range(level_size):
+                node = queue.popleft()
+                
+                if prev:
+                    prev.next = node
+                
+                prev = node
+                
+                if node.left:
+                    queue.append(node.left)
+                
+                if node.right:
+                    queue.append(node.right)
+        
         return root
 
 ```

From 61173277185bf7948ffb576212cc31fd383778e3 Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Wed, 3 May 2023 20:12:16 -0500
Subject: [PATCH 24/34] =?UTF-8?q?Update=200102.=E4=BA=8C=E5=8F=89=E6=A0=91?=
 =?UTF-8?q?=E7=9A=84=E5=B1=82=E5=BA=8F=E9=81=8D=E5=8E=86.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0102.二叉树的层序遍历.md | 31 ++++++++++++++---------
 1 file changed, 19 insertions(+), 12 deletions(-)

diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index 89e7a126..13694207 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -2664,24 +2664,31 @@ class Solution {
 Python：
 
 ```python 3
+# 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 maxDepth(self, root: TreeNode) -> int:
-        if root == None:
+        if not root:
             return 0
-
-        queue_ = [root]
+        
         depth = 0
-        while queue_:
-            length = len(queue_)
-            for i in range(length):
-                cur = queue_.pop(0)
-                sub.append(cur.val)
-                #子节点入队列
-                if cur.left: queue_.append(cur.left)
-                if cur.right: queue_.append(cur.right)
+        queue = collections.deque([root])
+        
+        while queue:
             depth += 1
-
+            for _ in range(len(queue)):
+                node = queue.popleft()
+                if node.left:
+                    queue.append(node.left)
+                if node.right:
+                    queue.append(node.right)
+        
         return depth
+
 ```
 
 Go：

From de7c67c35a5d3d0e423072d0b7cb02876c628786 Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Wed, 3 May 2023 20:13:38 -0500
Subject: [PATCH 25/34] =?UTF-8?q?Update=200102.=E4=BA=8C=E5=8F=89=E6=A0=91?=
 =?UTF-8?q?=E7=9A=84=E5=B1=82=E5=BA=8F=E9=81=8D=E5=8E=86.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0102.二叉树的层序遍历.md | 33 ++++++++++++-----------
 1 file changed, 18 insertions(+), 15 deletions(-)

diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index 13694207..c2ad9508 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -2938,23 +2938,26 @@ Python 3：
 #         self.right = right
 class Solution:
     def minDepth(self, root: TreeNode) -> int:
-        if root == None:
+        if not root:
             return 0
+        depth = 0
+        queue = collections.deque([root])
+        
+        while queue:
+            depth += 1 
+            for _ in range(len(queue)):
+                node = queue.popleft()
+                
+                if not node.left and not node.right:
+                    return depth
+            
+                if node.left:
+                    queue.append(node.left)
+                    
+                if node.right:
+                    queue.append(node.right)
 
-        #根节点的深度为1
-        queue_ = [(root,1)]
-        while queue_:
-            cur, depth = queue_.pop(0)
-
-            if cur.left == None and cur.right == None:
-                return depth
-            #先左子节点，由于左子节点没有孩子，则就是这一层了
-            if cur.left:
-                queue_.append((cur.left,depth + 1))
-            if cur.right:
-                queue_.append((cur.right,depth + 1))
-
-        return 0
+        return depth
 ```
 
 Go：

From 54bcab13e37ee1e609b567411b968bdb5a86abac Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Wed, 3 May 2023 20:25:30 -0500
Subject: [PATCH 26/34] =?UTF-8?q?Update=200226.=E7=BF=BB=E8=BD=AC=E4=BA=8C?=
 =?UTF-8?q?=E5=8F=89=E6=A0=91.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0226.翻转二叉树.md | 163 +++++++++++++++++++++++--------
 1 file changed, 120 insertions(+), 43 deletions(-)

diff --git a/problems/0226.翻转二叉树.md b/problems/0226.翻转二叉树.md
index 16a5be57..63baa409 100644
--- a/problems/0226.翻转二叉树.md
+++ b/problems/0226.翻转二叉树.md
@@ -314,81 +314,158 @@ class Solution {
 
 递归法：前序遍历：
 ```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 invertTree(self, root: TreeNode) -> TreeNode:
         if not root:
             return None
-        root.left, root.right = root.right, root.left #中
-        self.invertTree(root.left) #左
-        self.invertTree(root.right) #右
+        root.left, root.right = root.right, root.left
+        self.invertTree(root.left)
+        self.invertTree(root.right)
         return root
 ```
 
-递归法：后序遍历：
+迭代法：前序遍历：
 ```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 invertTree(self, root: TreeNode) -> TreeNode:
-        if root is None:
+        if not root:
+            return None      
+        stack = [root]        
+        while stack:
+            node = stack.pop()   
+            node.left, node.right = node.right, node.left                   
+            if node.left:
+                stack.append(node.left)
+            if node.right:
+                stack.append(node.right)  
+        return root
+```
+
+
+递归法：中序遍历：
+```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 invertTree(self, root: TreeNode) -> TreeNode:
+        if not root:
+            return None
+        self.invertTree(root.left)
+        root.left, root.right = root.right, root.left
+        self.invertTree(root.left)
+        return root
+```
+
+迭代法：中序遍历：
+```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 invertTree(self, root: TreeNode) -> TreeNode:
+        if not root:
+            return None      
+        stack = [root]        
+        while stack:
+            node = stack.pop()                   
+            if node.left:
+                stack.append(node.left)
+            node.left, node.right = node.right, node.left               
+            if node.left:
+                stack.append(node.left)       
+        return root
+```
+
+
+递归法：后序遍历：
+```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 invertTree(self, root: TreeNode) -> TreeNode:
+        if not root:
             return None
         self.invertTree(root.left)
         self.invertTree(root.right)
         root.left, root.right = root.right, root.left
-        return root 
+        return root
 ```
 
-迭代法：深度优先遍历（前序遍历）：
+迭代法：后序遍历：
 ```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 invertTree(self, root: TreeNode) -> TreeNode:
         if not root:
-            return root
-        st = []
-        st.append(root)
-        while st:
-            node = st.pop()
-            node.left, node.right = node.right, node.left #中
-            if node.right:
-                st.append(node.right) #右
+            return None      
+        stack = [root]        
+        while stack:
+            node = stack.pop()                   
             if node.left:
-                st.append(node.left) #左
+                stack.append(node.left)
+            if node.right:
+                stack.append(node.right)  
+            node.left, node.right = node.right, node.left               
+     
         return root
 ```
 
+
+
+
+
 迭代法：广度优先遍历（层序遍历）：
 ```python
-import collections
+# 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 invertTree(self, root: TreeNode) -> TreeNode:
-        queue = collections.deque() #使用deque()
-        if root:
-            queue.append(root)
+        if not root: 
+            return None
+
+        queue = collections.deque([root])    
         while queue:
-            size = len(queue)
-            for i in range(size):
+            for i in range(len(queue)):
                 node = queue.popleft()
-                node.left, node.right = node.right, node.left #节点处理
-                if node.left:
-                    queue.append(node.left)
-                if node.right:
-                    queue.append(node.right)
-        return root
-```
-迭代法：广度优先遍历（层序遍历），和之前的层序遍历写法一致：
-```python
-class Solution:
-    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
-        if not root: return root
-        from collections import deque
-        que=deque([root])    
-        while que:
-            size=len(que)
-            for i in range(size):
-                cur=que.popleft()
-                cur.left, cur.right = cur.right, cur.left
-                if cur.left: que.append(cur.left)
-                if cur.right: que.append(cur.right)
+                node.left, node.right = node.right, node.left
+                if node.left: queue.append(node.left)
+                if node.right: queue.append(node.right)
         return root   
+
 ```
+
 ### Go
 
 递归版本的前序遍历

From 918d0ec0faf27870212b11c4820d4ae956ba8da3 Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Wed, 3 May 2023 20:40:43 -0500
Subject: [PATCH 27/34] =?UTF-8?q?Update=200101.=E5=AF=B9=E7=A7=B0=E4=BA=8C?=
 =?UTF-8?q?=E5=8F=89=E6=A0=91.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0101.对称二叉树.md | 40 ++++++++++++++++++--------------
 1 file changed, 23 insertions(+), 17 deletions(-)

diff --git a/problems/0101.对称二叉树.md b/problems/0101.对称二叉树.md
index b75e9ff2..81ca79a2 100644
--- a/problems/0101.对称二叉树.md
+++ b/problems/0101.对称二叉树.md
@@ -442,25 +442,31 @@ class Solution:
 层次遍历
 ```python
 class Solution:
-    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
+    def isSymmetric(self, root: TreeNode) -> bool:
         if not root:
             return True
-
-        que = [root]
-        while que:
-            this_level_length = len(que)
-            for i in range(this_level_length // 2):
-                # 要么其中一个是None但另外一个不是
-                if (not que[i] and que[this_level_length - 1 - i]) or (que[i] and not que[this_level_length - 1 - i]):
-                    return False
-                # 要么两个都不是None
-                if que[i] and que[i].val != que[this_level_length - 1 - i].val:
-                    return False
-            for i in range(this_level_length):
-                if not que[i]: continue
-                que.append(que[i].left)
-                que.append(que[i].right)
-            que = que[this_level_length:]
+        
+        queue = collections.deque([root.left, root.right])
+        
+        while queue:
+            level_size = len(queue)
+            
+            if level_size % 2 != 0:
+                return False
+            
+            level_vals = []
+            for i in range(level_size):
+                node = queue.popleft()
+                if node:
+                    level_vals.append(node.val)
+                    queue.append(node.left)
+                    queue.append(node.right)
+                else:
+                    level_vals.append(None)
+                    
+            if level_vals != level_vals[::-1]:
+                return False
+            
         return True
 ```
 

From aac7378cb62ed2ec36fc1012f0057844297bda67 Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Wed, 3 May 2023 21:40:49 -0500
Subject: [PATCH 28/34] =?UTF-8?q?Update=200104.=E4=BA=8C=E5=8F=89=E6=A0=91?=
 =?UTF-8?q?=E7=9A=84=E6=9C=80=E5=A4=A7=E6=B7=B1=E5=BA=A6.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0104.二叉树的最大深度.md | 25 +++++++++++++++--------
 1 file changed, 16 insertions(+), 9 deletions(-)

diff --git a/problems/0104.二叉树的最大深度.md b/problems/0104.二叉树的最大深度.md
index 36578fd3..2294c1d9 100644
--- a/problems/0104.二叉树的最大深度.md
+++ b/problems/0104.二叉树的最大深度.md
@@ -419,26 +419,33 @@ class solution:
         return 1 + max(self.maxdepth(root.left), self.maxdepth(root.right))
 ```
 
-迭代法：
+层序遍历迭代法：
 ```python
-import collections
-class solution:
-    def maxdepth(self, root: treenode) -> int:
+# 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 maxDepth(self, root: TreeNode) -> int:
         if not root:
             return 0
-        depth = 0 #记录深度
-        queue = collections.deque()
-        queue.append(root)
+        
+        depth = 0
+        queue = collections.deque([root])
+        
         while queue:
-            size = len(queue)
             depth += 1
-            for i in range(size):
+            for _ in range(len(queue)):
                 node = queue.popleft()
                 if node.left:
                     queue.append(node.left)
                 if node.right:
                     queue.append(node.right)
+        
         return depth
+
 ```
 
 ### 559.n叉树的最大深度 

From 5da51519b5692ef2f450ba38b6299452a00f3b22 Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Wed, 3 May 2023 21:48:04 -0500
Subject: [PATCH 29/34] =?UTF-8?q?Update=200104.=E4=BA=8C=E5=8F=89=E6=A0=91?=
 =?UTF-8?q?=E7=9A=84=E6=9C=80=E5=A4=A7=E6=B7=B1=E5=BA=A6.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0104.二叉树的最大深度.md | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/problems/0104.二叉树的最大深度.md b/problems/0104.二叉树的最大深度.md
index 2294c1d9..c4d94d4d 100644
--- a/problems/0104.二叉树的最大深度.md
+++ b/problems/0104.二叉树的最大深度.md
@@ -452,14 +452,17 @@ class Solution:
 
 递归法：
 ```python
-class solution:
-    def maxdepth(self, root: 'node') -> int:
+class Solution:
+    def maxDepth(self, root: 'Node') -> int:
         if not root:
             return 0
-        depth = 0
-        for i in range(len(root.children)):
-            depth = max(depth, self.maxdepth(root.children[i]))
-        return depth + 1
+        
+        max_depth = 1
+        
+        for child in root.children:
+            max_depth = max(max_depth, self.maxDepth(child) + 1)
+        
+        return max_depth
 ```
 
 迭代法：

From be27cc547daf4c82a048b71f201c93ed3b2b3e2e Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Wed, 3 May 2023 21:57:13 -0500
Subject: [PATCH 30/34] =?UTF-8?q?Update=200104.=E4=BA=8C=E5=8F=89=E6=A0=91?=
 =?UTF-8?q?=E7=9A=84=E6=9C=80=E5=A4=A7=E6=B7=B1=E5=BA=A6.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0104.二叉树的最大深度.md | 33 ++++++++++++++---------
 1 file changed, 21 insertions(+), 12 deletions(-)

diff --git a/problems/0104.二叉树的最大深度.md b/problems/0104.二叉树的最大深度.md
index c4d94d4d..c55ddb3f 100644
--- a/problems/0104.二叉树的最大深度.md
+++ b/problems/0104.二叉树的最大深度.md
@@ -467,22 +467,31 @@ class Solution:
 
 迭代法：
 ```python
-import collections
-class solution:
-    def maxdepth(self, root: 'node') -> int:
-        queue = collections.deque()
-        if root:
-            queue.append(root)
-        depth = 0 #记录深度
+"""
+# Definition for a Node.
+class Node:
+    def __init__(self, val=None, children=None):
+        self.val = val
+        self.children = children
+"""
+
+class Solution:
+    def maxDepth(self, root: TreeNode) -> int:
+        if not root:
+            return 0
+        
+        depth = 0
+        queue = collections.deque([root])
+        
         while queue:
-            size = len(queue)
             depth += 1
-            for i in range(size):
+            for _ in range(len(queue)):
                 node = queue.popleft()
-                for j in range(len(node.children)):
-                    if node.children[j]:
-                        queue.append(node.children[j])
+                for child in node.children:
+                    queue.append(child)
+        
         return depth
+
 ```
 
 使用栈来模拟后序遍历依然可以

From 1b1b51750db1afcb812ba1250ea4fdc3e0395425 Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Wed, 3 May 2023 22:04:25 -0500
Subject: [PATCH 31/34] =?UTF-8?q?Update=200104.=E4=BA=8C=E5=8F=89=E6=A0=91?=
 =?UTF-8?q?=E7=9A=84=E6=9C=80=E5=A4=A7=E6=B7=B1=E5=BA=A6.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0104.二叉树的最大深度.md | 48 ++++++++++++-----------
 1 file changed, 25 insertions(+), 23 deletions(-)

diff --git a/problems/0104.二叉树的最大深度.md b/problems/0104.二叉树的最大深度.md
index c55ddb3f..b6208169 100644
--- a/problems/0104.二叉树的最大深度.md
+++ b/problems/0104.二叉树的最大深度.md
@@ -494,30 +494,32 @@ class Solution:
 
 ```
 
-使用栈来模拟后序遍历依然可以
+使用栈
 ```python
-class solution:
-    def maxdepth(self, root: 'node') -> int:
-        st = []
-        if root:
-            st.append(root)
-        depth = 0
-        result = 0
-        while st:
-            node = st.pop()
-            if node != none:
-                st.append(node) #中
-                st.append(none)
-                depth += 1
-                for i in range(len(node.children)): #处理孩子
-                    if node.children[i]:
-                        st.append(node.children[i])
-                    
-            else:
-                node = st.pop()
-                depth -= 1
-            result = max(result, depth)
-        return result
+"""
+# Definition for a Node.
+class Node:
+    def __init__(self, val=None, children=None):
+        self.val = val
+        self.children = children
+"""
+
+class Solution:
+    def maxDepth(self, root: 'Node') -> int:
+        if not root:
+            return 0
+        
+        max_depth = 0
+        
+        stack = [(root, 1)]
+        
+        while stack:
+            node, depth = stack.pop()
+            max_depth = max(max_depth, depth)
+            for child in node.children:
+                stack.append((child, depth + 1))
+        
+        return max_depth
 ```
 
 

From 75d137eb1c0464de0321f611ed66125e322936e7 Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Thu, 4 May 2023 00:23:53 -0500
Subject: [PATCH 32/34] =?UTF-8?q?Update=200111.=E4=BA=8C=E5=8F=89=E6=A0=91?=
 =?UTF-8?q?=E7=9A=84=E6=9C=80=E5=B0=8F=E6=B7=B1=E5=BA=A6.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0111.二叉树的最小深度.md | 59 +++++++++++++++--------
 1 file changed, 39 insertions(+), 20 deletions(-)

diff --git a/problems/0111.二叉树的最小深度.md b/problems/0111.二叉树的最小深度.md
index de36c6f2..bda12ff0 100644
--- a/problems/0111.二叉树的最小深度.md
+++ b/problems/0111.二叉树的最小深度.md
@@ -300,44 +300,63 @@ class Solution {
 递归法：
 
 ```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 minDepth(self, root: TreeNode) -> int:
         if not root:
             return 0
+        
         if not root.left and not root.right:
             return 1
-
-        min_depth = 10**9
+        
+        left_depth = float('inf')
+        right_depth = float('inf')
+        
         if root.left:
-            min_depth = min(self.minDepth(root.left), min_depth) # 获得左子树的最小高度
+            left_depth = self.minDepth(root.left)
         if root.right:
-            min_depth = min(self.minDepth(root.right), min_depth) # 获得右子树的最小高度
-        return min_depth + 1
+            right_depth = self.minDepth(root.right)
+        
+        return 1 + min(left_depth, right_depth)
+
 ```
 
 迭代法：
 
 ```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 minDepth(self, root: TreeNode) -> int:
         if not root:
             return 0
-        que = deque()
-        que.append(root)
-        res = 1
-
-        while que:
-            for _ in range(len(que)):
-                node = que.popleft()
-                # 当左右孩子都为空的时候，说明是最低点的一层了，退出
+        depth = 0
+        queue = collections.deque([root])
+        
+        while queue:
+            depth += 1 
+            for _ in range(len(queue)):
+                node = queue.popleft()
+                
                 if not node.left and not node.right:
-                    return res
-                if node.left is not None:
-                    que.append(node.left)
-                if node.right is not None:
-                    que.append(node.right)
-            res += 1
-        return res
+                    return depth
+            
+                if node.left:
+                    queue.append(node.left)
+                    
+                if node.right:
+                    queue.append(node.right)
+
+        return depth
 ```
 
 

From d15c54f43fe0df608d207f269e8bb589c5cebd3d Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Thu, 4 May 2023 00:26:20 -0500
Subject: [PATCH 33/34] =?UTF-8?q?Update=200111.=E4=BA=8C=E5=8F=89=E6=A0=91?=
 =?UTF-8?q?=E7=9A=84=E6=9C=80=E5=B0=8F=E6=B7=B1=E5=BA=A6.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0111.二叉树的最小深度.md | 33 +++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/problems/0111.二叉树的最小深度.md b/problems/0111.二叉树的最小深度.md
index bda12ff0..0c086f1b 100644
--- a/problems/0111.二叉树的最小深度.md
+++ b/problems/0111.二叉树的最小深度.md
@@ -359,6 +359,39 @@ class Solution:
         return depth
 ```
 
+迭代法：
+
+```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 minDepth(self, root: TreeNode) -> int:
+        if not root:
+            return 0
+        
+        queue = collections.deque([(root, 1)])
+        
+        while queue:
+            node, depth = queue.popleft()
+            
+            # Check if the node is a leaf node
+            if not node.left and not node.right:
+                return depth
+            
+            # Add left and right child to the queue
+            if node.left:
+                queue.append((node.left, depth+1))
+            if node.right:
+                queue.append((node.right, depth+1))
+        
+        return 0
+
+```
 
 ## Go
 

From 3d59f732e0479c12657f5a6020b4ed5784222780 Mon Sep 17 00:00:00 2001
From: jianghongcheng <35664721+jianghongcheng@users.noreply.github.com>
Date: Thu, 4 May 2023 01:35:13 -0500
Subject: [PATCH 34/34] =?UTF-8?q?Update=200222.=E5=AE=8C=E5=85=A8=E4=BA=8C?=
 =?UTF-8?q?=E5=8F=89=E6=A0=91=E7=9A=84=E8=8A=82=E7=82=B9=E4=B8=AA=E6=95=B0?=
 =?UTF-8?q?.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 problems/0222.完全二叉树的节点个数.md | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/problems/0222.完全二叉树的节点个数.md b/problems/0222.完全二叉树的节点个数.md
index d89a9bce..795a6f37 100644
--- a/problems/0222.完全二叉树的节点个数.md
+++ b/problems/0222.完全二叉树的节点个数.md
@@ -393,6 +393,20 @@ class Solution: # 利用完全二叉树特性
             return 2**count-1
         return 1+self.countNodes(root.left)+self.countNodes(root.right)  
 ```
+完全二叉树写法3
+```python
+class Solution: # 利用完全二叉树特性
+    def countNodes(self, root: TreeNode) -> int:
+        if not root: return 0
+        count = 0
+        left = root.left; right = root.right
+        while left and right:
+            count+=1
+            left = left.left; right = right.right
+        if not left and not right: # 如果同时到底说明是满二叉树，反之则不是
+            return (2<<count)-1
+        return 1+self.countNodes(root.left)+self.countNodes(root.right)  
+```
 
 ## Go