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] =?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
 
 递归版本的前序遍历