Merge pull request #1787 from juguagua/leetcode-modify-the-code-of-the-BinaryTree

完善更新二叉树部分：从 二叉树遍历 至 对称二叉树

problems/0101.对称二叉树.md

@@ -21,7 +21,7 @@
 
 对于二叉树是否对称，要比较的是根节点的左子树与右子树是不是相互翻转的，理解这一点就知道了**其实我们要比较的是两个树（这两个树是根节点的左右子树）**，所以在递归遍历的过程中，也是要同时遍历两棵树。
 
-那么如果比较呢？
+那么如何比较呢？
 
 比较的是两个子树的里侧和外侧的元素是否相等。如图所示：
 
@@ -244,7 +244,7 @@ public:
 
 这次我们又深度剖析了一道二叉树的“简单题”，大家会发现，真正的把题目搞清楚其实并不简单，leetcode上accept了和真正掌握了还是有距离的。
 
-我们介绍了递归法和迭代法，递归依然通过递归三部曲来解决了这道题目，如果只看精简的代码根本看不出来递归三部曲是如果解题的。
+我们介绍了递归法和迭代法，递归依然通过递归三部曲来解决了这道题目，如果只看精简的代码根本看不出来递归三部曲是如何解题的。
 
 在迭代法中我们使用了队列，需要注意的是这不是层序遍历，而且仅仅通过一个容器来成对的存放我们要比较的元素，知道这一本质之后就发现，用队列，用栈，甚至用数组，都是可以的。
 
@@ -259,7 +259,7 @@ public:
 
 # 其他语言版本
 
-## Java
+Java
 
 ```Java
     /**
@@ -364,7 +364,7 @@ public:
 
 ```
 
-## Python
+Python
 
 递归法:
 ```python
@@ -464,8 +464,7 @@ class Solution:
         return True
 ```
 
-## Go
-
+Go
 ```go
 /**
  * Definition for a binary tree node.
@@ -488,10 +487,12 @@ func defs(left *TreeNode, right *TreeNode) bool {
     }
     return defs(left.Left, right.Right) && defs(right.Left, left.Right);
 }
+
 func isSymmetric(root *TreeNode) bool {
     return defs(root.Left, root.Right);
 }
 
+
 // 迭代
 func isSymmetric(root *TreeNode) bool {
     var queue []*TreeNode;
@@ -515,7 +516,7 @@ func isSymmetric(root *TreeNode) bool {
 ```
 
 
-## JavaScript
+JavaScript
 
 递归判断是否为对称二叉树：
 ```javascript
@@ -568,6 +569,7 @@ var isSymmetric = function(root) {
       queue.push(leftNode.right);    //左节点右孩子入队
       queue.push(rightNode.left);    //右节点左孩子入队
   }
+  
   return true;
 };
 ```
@@ -597,11 +599,12 @@ var isSymmetric = function(root) {
       stack.push(leftNode.right);     //左节点右孩子入队
       stack.push(rightNode.left);     //右节点左孩子入队
   }
+  
   return true;
 };
 ```
 
-## TypeScript：
+TypeScript：
 
 > 递归法
 
@@ -670,7 +673,7 @@ function isSymmetric(root: TreeNode | null): boolean {
 };
 ```
 
-## Swift:
+Swift:
 
 > 递归
 ```swift
@@ -752,7 +755,7 @@ func isSymmetric3(_ root: TreeNode?) -> Bool {
 }
 ```
 
-## Scala
+Scala
 
 > 递归：
 ```scala

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

@@ -47,7 +47,7 @@
 
 层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。这种遍历的方式和我们之前讲过的都不太一样。
 
-需要借用一个辅助数据结构即队列来实现，**队列先进先出，符合一层一层遍历的逻辑，而是用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。**
+需要借用一个辅助数据结构即队列来实现，**队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。**
 
 **而这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。**
 
@@ -106,50 +106,6 @@ public:
 };
 ```
 
-python3代码：
-
-
-```python
-
-class Solution:
-    """二叉树层序遍历迭代解法"""
-
-    def levelOrder(self, root: TreeNode) -> List[List[int]]:
-        results = []
-        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)
-                if cur.left:
-                    que.append(cur.left)
-                if cur.right:
-                    que.append(cur.right)
-            results.append(result)
-
-        return results
-```
-```python
-# 递归法
-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
-```
 java: 
 
 ```Java
@@ -206,6 +162,51 @@ class Solution {
 }
 ```
 
+python3代码：
+
+
+```python
+
+class Solution:
+    """二叉树层序遍历迭代解法"""
+
+    def levelOrder(self, root: TreeNode) -> List[List[int]]:
+        results = []
+        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)
+                if cur.left:
+                    que.append(cur.left)
+                if cur.right:
+                    que.append(cur.right)
+            results.append(result)
+
+        return results
+```
+```python
+# 递归法
+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
+```
+
 go: 
 
 ```go
@@ -249,7 +250,9 @@ func levelOrder(root *TreeNode) [][]int {
     }
     queue := list.New()
     queue.PushBack(root)
+    
     var tmpArr []int
+    
     for queue.Len() > 0 {
         length := queue.Len()               //保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
         for i := 0; i < length; i++ {
@@ -265,6 +268,7 @@ func levelOrder(root *TreeNode) [][]int {
         res = append(res, tmpArr)          //放入结果集
         tmpArr = []int{}                  //清空层的数据
     }
+    
     return res
 }
 ```
@@ -541,6 +545,7 @@ func levelOrderBottom(root *TreeNode) [][]int {
         return res
     }
     queue.PushBack(root)
+    
     for queue.Len() > 0 {
         length := queue.Len()
         tmp := []int{}
@@ -556,10 +561,12 @@ func levelOrderBottom(root *TreeNode) [][]int {
         }
         res=append(res, tmp)
     }
+    
     //反转结果集
     for i:=0; i<len(res)/2; i++ {
         res[i], res[len(res)-i-1] = res[len(res)-i-1], res[i]
     }
+    
     return res
 }
 ```
@@ -854,6 +861,7 @@ var rightSideView = function(root) {
     //二叉树右视图 只需要把每一层最后一个节点存储到res数组
     let res = [], queue = [];
     queue.push(root);
+    
     while(queue.length && root!==null) {
         // 记录当前层级节点个数
         let length = queue.length;
@@ -867,6 +875,7 @@ var rightSideView = function(root) {
             node.right && queue.push(node.right);
         }
     }
+    
     return res;
 };
 ```
@@ -1131,6 +1140,7 @@ var averageOfLevels = function(root) {
     //层级平均值
     let res = [], queue = [];
     queue.push(root);
+    
     while(queue.length && root!==null) {
         //每一层节点个数
         let length = queue.length;
@@ -1145,6 +1155,7 @@ var averageOfLevels = function(root) {
         //每一层的平均值存入数组res
         res.push(sum/length);
     }
+    
     return res;
 };
 ```
@@ -1423,6 +1434,7 @@ func levelOrder(root *Node) [][]int {
         }
         res = append(res, tmp)
     }
+    
     return res
 }
 ```
@@ -1434,6 +1446,7 @@ var levelOrder = function(root) {
     //每一层可能有2个以上,所以不再使用node.left node.right
     let res = [], queue = [];
     queue.push(root);
+    
     while(queue.length && root!==null) {
         //记录每一层节点个数还是和二叉树一致
         let length = queue.length;
@@ -1442,6 +1455,7 @@ var levelOrder = function(root) {
         while(length--) {
             let node = queue.shift();
             curLevel.push(node.val);
+	    
             //这里不再是 ndoe.left node.right 而是循坏node.children
            for(let item of node.children){
                item && queue.push(item);
@@ -1449,6 +1463,7 @@ var levelOrder = function(root) {
         }
         res.push(curLevel);
     }
+    
     return res;
 };
 ```
@@ -1710,6 +1725,7 @@ var largestValues = function(root) {
     //使用层序遍历
     let res = [], queue = [];
     queue.push(root);
+    
     while(root !== null && queue.length) { 
         //设置max初始值就是队列的第一个元素
         let max = queue[0].val;
@@ -1723,6 +1739,7 @@ var largestValues = function(root) {
         //把每一层的最大值放到res数组
         res.push(max);
     }
+    
     return res;
 };
 ```
@@ -1964,6 +1981,46 @@ class Solution:
             first = first.left  # 从本层扩展到下一层
         return root
 ```
+go:
+
+```GO
+/**
+116. 填充每个节点的下一个右侧节点指针
+117. 填充每个节点的下一个右侧节点指针 II
+ */
+
+func connect(root *Node) *Node {
+    if root == nil { //防止为空
+        return root
+    }
+    queue := list.New()
+    queue.PushBack(root)
+    tmpArr := make([]*Node, 0)
+    for queue.Len() > 0 {
+        length := queue.Len() //保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
+        for i := 0; i < length; i++ {
+            node := queue.Remove(queue.Front()).(*Node) //出队列
+            if node.Left != nil {
+                queue.PushBack(node.Left)
+            }
+            if node.Right != nil {
+                queue.PushBack(node.Right)
+            }
+            tmpArr = append(tmpArr, node) //将值加入本层切片中
+        }
+        if len(tmpArr) > 1 {
+            // 遍历每层元素,指定next
+            for i := 0; i < len(tmpArr)-1; i++ {
+                tmpArr[i].Next = tmpArr[i+1]
+            }
+        }
+        tmpArr = []*Node{} //清空层的数据
+    }
+    return root
+}
+
+```
+
 JavaScript:
 ```javascript
 
@@ -2024,46 +2081,6 @@ function connect(root: Node | null): Node | null {
 };
 ```
 
-go:
-
-```GO
-/**
-116. 填充每个节点的下一个右侧节点指针
-117. 填充每个节点的下一个右侧节点指针 II
- */
-
-func connect(root *Node) *Node {
-    if root == nil { //防止为空
-        return root
-    }
-    queue := list.New()
-    queue.PushBack(root)
-    tmpArr := make([]*Node, 0)
-    for queue.Len() > 0 {
-        length := queue.Len() //保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
-        for i := 0; i < length; i++ {
-            node := queue.Remove(queue.Front()).(*Node) //出队列
-            if node.Left != nil {
-                queue.PushBack(node.Left)
-            }
-            if node.Right != nil {
-                queue.PushBack(node.Right)
-            }
-            tmpArr = append(tmpArr, node) //将值加入本层切片中
-        }
-        if len(tmpArr) > 1 {
-            // 遍历每层元素,指定next
-            for i := 0; i < len(tmpArr)-1; i++ {
-                tmpArr[i].Next = tmpArr[i+1]
-            }
-        }
-        tmpArr = []*Node{} //清空层的数据
-    }
-    return root
-}
-
-```
-
 Swift：
 
 ```swift
@@ -2226,6 +2243,45 @@ class Solution:
         return root
 
 ```
+go:
+
+```GO
+/**
+116. 填充每个节点的下一个右侧节点指针
+117. 填充每个节点的下一个右侧节点指针 II
+ */
+
+func connect(root *Node) *Node {
+    if root == nil { //防止为空
+        return root
+    }
+    queue := list.New()
+    queue.PushBack(root)
+    tmpArr := make([]*Node, 0)
+    for queue.Len() > 0 {
+        length := queue.Len() //保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
+        for i := 0; i < length; i++ {
+            node := queue.Remove(queue.Front()).(*Node) //出队列
+            if node.Left != nil {
+                queue.PushBack(node.Left)
+            }
+            if node.Right != nil {
+                queue.PushBack(node.Right)
+            }
+            tmpArr = append(tmpArr, node) //将值加入本层切片中
+        }
+        if len(tmpArr) > 1 {
+            // 遍历每层元素,指定next
+            for i := 0; i < len(tmpArr)-1; i++ {
+                tmpArr[i].Next = tmpArr[i+1]
+            }
+        }
+        tmpArr = []*Node{} //清空层的数据
+    }
+    return root
+}
+```
+
 JavaScript:
 ```javascript
 /**
@@ -2284,44 +2340,6 @@ function connect(root: Node | null): Node | null {
 };
 ```
 
-go:
-
-```GO
-/**
-116. 填充每个节点的下一个右侧节点指针
-117. 填充每个节点的下一个右侧节点指针 II
- */
-
-func connect(root *Node) *Node {
-    if root == nil { //防止为空
-        return root
-    }
-    queue := list.New()
-    queue.PushBack(root)
-    tmpArr := make([]*Node, 0)
-    for queue.Len() > 0 {
-        length := queue.Len() //保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
-        for i := 0; i < length; i++ {
-            node := queue.Remove(queue.Front()).(*Node) //出队列
-            if node.Left != nil {
-                queue.PushBack(node.Left)
-            }
-            if node.Right != nil {
-                queue.PushBack(node.Right)
-            }
-            tmpArr = append(tmpArr, node) //将值加入本层切片中
-        }
-        if len(tmpArr) > 1 {
-            // 遍历每层元素,指定next
-            for i := 0; i < len(tmpArr)-1; i++ {
-                tmpArr[i].Next = tmpArr[i+1]
-            }
-        }
-        tmpArr = []*Node{} //清空层的数据
-    }
-    return root
-}
-```
 Swift：
 
 ```swift
@@ -2461,7 +2479,6 @@ class Solution {
 }
 ```
 
-
 Python：
 ```python 3
 class Solution:
@@ -2521,8 +2538,6 @@ func maxDepth(root *TreeNode) int {
 }
 ```
 
-
-
 JavaScript：
 ```javascript
 /**
@@ -2784,9 +2799,8 @@ func minDepth(root *TreeNode) int {
             }
         }
         ans++//记录层数
-        
-
     }
+    
     return ans+1
 }
 ```

problems/0226.翻转二叉树.md

@@ -104,7 +104,7 @@ public:
 
 ### 深度优先遍历
 
-[二叉树：听说递归能做的，栈也能做！](https://programmercarl.com/二叉树的迭代遍历.html)中给出了前中后序迭代方式的写法，所以本地可以很轻松的切出如下迭代法的代码：
+[二叉树：听说递归能做的，栈也能做！](https://programmercarl.com/二叉树的迭代遍历.html)中给出了前中后序迭代方式的写法，所以本题可以很轻松的写出如下迭代法的代码：
 
 C++代码迭代法（前序遍历）
 
@@ -126,7 +126,7 @@ public:
     }
 };
 ```
-如果这个代码看不懂的话可以在回顾一下[二叉树：听说递归能做的，栈也能做！](https://programmercarl.com/二叉树的迭代遍历.html)。
+如果这个代码看不懂的话可以再回顾一下[二叉树：听说递归能做的，栈也能做！](https://programmercarl.com/二叉树的迭代遍历.html)。
 
 
 我们在[二叉树：前中后序迭代方式的统一写法](https://programmercarl.com/二叉树的统一迭代法.html)中介绍了统一的写法，所以，本题也只需将文中的代码少做修改便可。
@@ -258,7 +258,6 @@ public:
 
 
 ### Java
-
 ```Java
 //DFS递归
 class Solution {
@@ -294,8 +293,8 @@ class Solution {
             while (size-- > 0) {
                 TreeNode node = deque.poll();
                 swap(node);
-                if (node.left != null) {deque.offer(node.left);}
-                if (node.right != null) {deque.offer(node.right);}
+                if (node.left != null) deque.offer(node.left);
+                if (node.right != null) deque.offer(node.right);
             }
         }
         return root;
@@ -364,7 +363,6 @@ class Solution:
 ### Go
 
 递归版本的前序遍历
-
 ```Go
 func invertTree(root *TreeNode) *TreeNode {
     if root == nil {
@@ -386,9 +384,11 @@ func invertTree(root *TreeNode) *TreeNode {
     if root == nil {
         return root
     }
+    
     invertTree(root.Left)     //遍历左节点
     invertTree(root.Right)    //遍历右节点
     root.Left, root.Right = root.Right, root.Left    //交换
+    
     return root
 }
 ```
@@ -409,6 +409,7 @@ func invertTree(root *TreeNode) *TreeNode {
         stack = stack[:len(stack)-1]
         node = node.Right
     }
+    
     return root
 }
 ```
@@ -436,6 +437,7 @@ func invertTree(root *TreeNode) *TreeNode {
             node = node.Right
         }
     }
+    
     return root
 }
 ```
@@ -760,7 +762,6 @@ func invertTree1(_ root: TreeNode?) -> TreeNode? {
 }
 ```
 
-### Swift
 
 深度优先递归。
 
@@ -808,9 +809,6 @@ func invertTree(_ root: TreeNode?) -> TreeNode? {
     return root
 }
 ```
-
-### Scala
-
 深度优先遍历（前序遍历）:
 ```scala
 object Solution {

problems/二叉树理论基础.md

@@ -14,7 +14,7 @@
 
 <img src='https://img-blog.csdnimg.cn/20210219190809451.png' width=600 alt='二叉树大纲'> </img></div>
 
-说道二叉树，大家对于二叉树其实都很熟悉了，本文呢我也不想教科书式的把二叉树的基础内容在啰嗦一遍，所以一下我讲的都是一些比较重点的内容。
+说到二叉树，大家对于二叉树其实都很熟悉了，本文呢我也不想教科书式的把二叉树的基础内容再啰嗦一遍，所以以下我讲的都是一些比较重点的内容。
 
 相信只要耐心看完，都会有所收获。
 
@@ -83,7 +83,7 @@
 
 那么链式存储方式就用指针， 顺序存储的方式就是用数组。
 
-顾名思义就是顺序存储的元素在内存是连续分布的，而链式存储则是通过指针把分布在散落在各个地址的节点串联一起。
+顾名思义就是顺序存储的元素在内存是连续分布的，而链式存储则是通过指针把分布在各个地址的节点串联一起。
 
 链式存储如图：
 
@@ -143,7 +143,7 @@
 
 最后再说一说二叉树中深度优先和广度优先遍历实现方式，我们做二叉树相关题目，经常会使用递归的方式来实现深度优先遍历，也就是实现前中后序遍历，使用递归是比较方便的。
 
-**之前我们讲栈与队列的时候，就说过栈其实就是递归的一种是实现结构**，也就说前中后序遍历的逻辑其实都是可以借助栈使用非递归的方式来实现的。
+**之前我们讲栈与队列的时候，就说过栈其实就是递归的一种实现结构**，也就说前中后序遍历的逻辑其实都是可以借助栈使用非递归的方式来实现的。
 
 而广度优先遍历的实现一般使用队列来实现，这也是队列先进先出的特点所决定的，因为需要先进先出的结构，才能一层一层的来遍历二叉树。
 

problems/二叉树的递归遍历.md

@@ -36,13 +36,13 @@
 
 **以下以前序遍历为例：**
 
-1. **确定递归函数的参数和返回值**：因为要打印出前序遍历节点的数值，所以参数里需要传入vector在放节点的数值，除了这一点就不需要在处理什么数据了也不需要有返回值，所以递归函数返回类型就是void，代码如下：
+1. **确定递归函数的参数和返回值**：因为要打印出前序遍历节点的数值，所以参数里需要传入vector来放节点的数值，除了这一点就不需要再处理什么数据了也不需要有返回值，所以递归函数返回类型就是void，代码如下：
 
 ```cpp
 void traversal(TreeNode* cur, vector<int>& vec)
 ```
 
-2. **确定终止条件**：在递归的过程中，如何算是递归结束了呢，当然是当前遍历的节点是空了，那么本层递归就要要结束了，所以如果当前遍历的这个节点是空，就直接return，代码如下：
+2. **确定终止条件**：在递归的过程中，如何算是递归结束了呢，当然是当前遍历的节点是空了，那么本层递归就要结束了，所以如果当前遍历的这个节点是空，就直接return，代码如下：
 
 ```cpp
 if (cur == NULL) return;