diff --git a/problems/0101.对称二叉树.md b/problems/0101.对称二叉树.md
index 4418c62d..36b39740 100644
--- a/problems/0101.对称二叉树.md
+++ b/problems/0101.对称二叉树.md
@@ -13,9 +13,11 @@
 
 ![101. 对称二叉树](https://code-thinking-1253855093.file.myqcloud.com/pics/20210203144607387.png)
 
-# 思路
+## 算法公开课
 
-《代码随想录》算法视频公开课：[同时操作两个二叉树 | LeetCode：101. 对称二叉树](https://www.bilibili.com/video/BV1ue4y1Y7Mf)，相信结合视频在看本篇题解，更有助于大家对本题的理解。
+**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[同时操作两个二叉树 | LeetCode：101. 对称二叉树](https://www.bilibili.com/video/BV1ue4y1Y7Mf)， 相信结合视频再看本篇题解，更有助于大家对本题的理解**。
+
+## 思路
 
 **首先想清楚，判断对称二叉树要比较的是哪两个节点，要比较的可不是左右节点！**
 
@@ -41,7 +43,7 @@
 
 那么我们先来看看递归法的代码应该怎么写。
 
-## 递归法
+### 递归法
 
 递归三部曲
 
@@ -159,13 +161,13 @@ public:
 
 **所以建议大家做题的时候，一定要想清楚逻辑，每一步做什么。把题目所有情况想到位，相应的代码写出来之后，再去追求简洁代码的效果。**
 
-## 迭代法
+### 迭代法
 
 这道题目我们也可以使用迭代法，但要注意，这里的迭代法可不是前中后序的迭代写法，因为本题的本质是判断两个树是否是相互翻转的，其实已经不是所谓二叉树遍历的前中后序的关系了。
 
 这里我们可以使用队列来比较两个树（根节点的左右子树）是否相互翻转，（**注意这不是层序遍历**）
 
-### 使用队列
+#### 使用队列
 
 通过队列来判断根节点的左子树和右子树的内侧和外侧是否相等，如动画所示：
 
@@ -207,7 +209,7 @@ public:
 };
 ```
 
-### 使用栈
+#### 使用栈
 
 细心的话，其实可以发现，这个迭代法，其实是把左右两个子树要比较的元素顺序放进一个容器，然后成对成对的取出来进行比较，那么其实使用栈也是可以的。
 
@@ -254,12 +256,12 @@ public:
 
 这两道题目基本和本题是一样的，只要稍加修改就可以AC。
 
-* 100.相同的树
-* 572.另一个树的子树
+* [100.相同的树](https://leetcode.cn/problems/same-tree/)
+* [572.另一个树的子树](https://leetcode.cn/problems/subtree-of-another-tree/)
 
-# 其他语言版本
+## 其他语言版本
 
-Java
+### Java:
 
 ```Java
     /**
@@ -364,7 +366,7 @@ Java
 
 ```
 
-Python
+### Python:
 
 递归法:
 ```python
@@ -470,7 +472,8 @@ class Solution:
         return True
 ```
 
-Go
+### Go:
+
 ```go
 /**
  * Definition for a binary tree node.
@@ -521,8 +524,7 @@ func isSymmetric(root *TreeNode) bool {
 }
 ```
 
-
-JavaScript
+### JavaScript:
 
 递归判断是否为对称二叉树：
 ```javascript
@@ -610,7 +612,7 @@ var isSymmetric = function(root) {
 };
 ```
 
-TypeScript：
+### TypeScript：
 
 > 递归法
 
@@ -679,7 +681,7 @@ function isSymmetric(root: TreeNode | null): boolean {
 };
 ```
 
-Swift:
+### Swift:
 
 > 递归
 ```swift
@@ -761,7 +763,7 @@ func isSymmetric3(_ root: TreeNode?) -> Bool {
 }
 ```
 
-Scala
+### Scala:
 
 > 递归：
 ```scala
@@ -835,7 +837,7 @@ object Solution {
 }
 ```
 
-## Rust
+### Rust:
 
 递归：
 ```rust
@@ -900,3 +902,4 @@ impl Solution {
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
 </a>
+
diff --git a/problems/0102.二叉树的层序遍历.md b/problems/0102.二叉树的层序遍历.md
index c2ad9508..ce9a247c 100644
--- a/problems/0102.二叉树的层序遍历.md
+++ b/problems/0102.二叉树的层序遍历.md
@@ -8,21 +8,23 @@
 
 # 二叉树层序遍历登场！
 
-《代码随想录》算法视频公开课：[讲透二叉树的层序遍历 | 广度优先搜索 | LeetCode：102.二叉树的层序遍历](https://www.bilibili.com/video/BV1GY4y1u7b2)，相信结合视频在看本篇题解，更有助于大家对本题的理解。
+## 算法公开课
+
+**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[讲透二叉树的层序遍历 | 广度优先搜索 | LeetCode：102.二叉树的层序遍历](https://www.bilibili.com/video/BV1GY4y1u7b2)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
 
 
 学会二叉树的层序遍历，可以一口气打完以下十题：
 
-* 102.二叉树的层序遍历
-* 107.二叉树的层次遍历II
-* 199.二叉树的右视图
-* 637.二叉树的层平均值
-* 429.N叉树的层序遍历
-* 515.在每个树行中找最大值
-* 116.填充每个节点的下一个右侧节点指针
-* 117.填充每个节点的下一个右侧节点指针II
-* 104.二叉树的最大深度
-* 111.二叉树的最小深度
+* [102.二叉树的层序遍历](https://leetcode.cn/problems/binary-tree-level-order-traversal/)
+* [107.二叉树的层次遍历II](https://leetcode.cn/problems/binary-tree-level-order-traversal-ii/)
+* [199.二叉树的右视图](https://leetcode.cn/problems/binary-tree-right-side-view/)
+* [637.二叉树的层平均值](https://leetcode.cn/problems/binary-tree-right-side-view/)
+* [429.N叉树的层序遍历](https://leetcode.cn/problems/n-ary-tree-level-order-traversal/)
+* [515.在每个树行中找最大值](https://leetcode.cn/problems/find-largest-value-in-each-tree-row/)
+* [116.填充每个节点的下一个右侧节点指针](https://leetcode.cn/problems/populating-next-right-pointers-in-each-node/)
+* [117.填充每个节点的下一个右侧节点指针II](https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii/)
+* [104.二叉树的最大深度](https://leetcode.cn/problems/maximum-depth-of-binary-tree/)
+* [111.二叉树的最小深度](https://leetcode.cn/problems/minimum-depth-of-binary-tree/)
 
 
 
@@ -31,7 +33,7 @@
 
 
 
-# 102.二叉树的层序遍历
+## 102.二叉树的层序遍历
 
 [力扣题目链接](https://leetcode.cn/problems/binary-tree-level-order-traversal/)
 
@@ -39,7 +41,7 @@
 
 ![102.二叉树的层序遍历](https://code-thinking-1253855093.file.myqcloud.com/pics/20210203144842988.png)
 
-思路：
+### 思路
 
 我们之前讲过了三篇关于二叉树的深度优先遍历的文章：
 
@@ -63,7 +65,7 @@
 
 代码如下：**这份代码也可以作为二叉树层序遍历的模板，打十个就靠它了**。
 
-C++代码：
+c++代码如下：
 
 ```CPP
 class Solution {
@@ -111,7 +113,9 @@ public:
 };
 ```
 
-java:
+### 其他语言版本
+
+#### Java:
 
 ```Java
 // 102.二叉树的层序遍历
@@ -167,7 +171,7 @@ class Solution {
 }
 ```
 
-python3代码：
+#### Python:
 
 
 ```python
@@ -219,12 +223,9 @@ class Solution:
         self.helper(node.left, level + 1, levels)
         self.helper(node.right, level + 1, levels)
 
-
 ```
 
-
-
-go:
+#### Go:
 
 ```go
 /**
@@ -320,7 +321,7 @@ func levelOrder(root *TreeNode) (res [][]int) {
 }
 ```
 
-javascript代码：
+#### Javascript：
 
 ```javascript
 var levelOrder = function(root) {
@@ -350,7 +351,7 @@ var levelOrder = function(root) {
 
 ```
 
-TypeScript：
+#### TypeScript：
 
 ```typescript
 function levelOrder(root: TreeNode | null): number[][] {
@@ -377,7 +378,7 @@ function levelOrder(root: TreeNode | null): number[][] {
 };
 ```
 
-Swift：
+#### Swift：
 
 ```swift
 func levelOrder(_ root: TreeNode?) -> [[Int]] {
@@ -403,7 +404,7 @@ func levelOrder(_ root: TreeNode?) -> [[Int]] {
 }
 ```
 
-Scala:
+#### Scala:
 
 ```scala
 // 102.二叉树的层序遍历
@@ -430,7 +431,7 @@ object Solution {
 }
 ```
 
-Rust:
+#### Rust:
 
 ```rust
 use std::cell::RefCell;
@@ -466,7 +467,7 @@ impl Solution {
 **此时我们就掌握了二叉树的层序遍历了，那么如下九道力扣上的题目，只需要修改模板的两三行代码（不能再多了），便可打倒！**
 
 
-# 107.二叉树的层次遍历 II
+## 107.二叉树的层次遍历 II
 
 [力扣题目链接](https://leetcode.cn/problems/binary-tree-level-order-traversal-ii/)
 
@@ -474,7 +475,7 @@ impl Solution {
 
 ![107.二叉树的层次遍历II](https://code-thinking-1253855093.file.myqcloud.com/pics/20210203151058308.png)
 
-思路：
+### 思路
 
 相对于102.二叉树的层序遍历，就是最后把result数组反转一下就可以了。
 
@@ -506,7 +507,9 @@ public:
 };
 ```
 
-python代码：
+### 其他语言版本
+
+#### Python：
 
 ```python
 class Solution:
@@ -537,7 +540,7 @@ class Solution:
         return result[::-1]
 ```
 
-Java：
+#### Java：
 
 ```java
 // 107. 二叉树的层序遍历 II
@@ -618,12 +621,10 @@ class Solution {
 
         return ans;
     }
-}
+
 ```
 
-
-
-go:
+#### Go:
 
 ```GO
 /**
@@ -662,7 +663,7 @@ func levelOrderBottom(root *TreeNode) [][]int {
 }
 ```
 
-javascript代码
+#### Javascript:
 
 ```javascript
 var levelOrderBottom = function(root) {
@@ -688,7 +689,7 @@ var levelOrderBottom = function(root) {
 };
 ```
 
-TypeScript:
+#### TypeScript:
 
 ```typescript
 function levelOrderBottom(root: TreeNode | null): number[][] {
@@ -711,7 +712,7 @@ function levelOrderBottom(root: TreeNode | null): number[][] {
 };
 ```
 
-Swift：
+#### Swift：
 
 ```swift
 func levelOrderBottom(_ root: TreeNode?) -> [[Int]] {
@@ -737,8 +738,7 @@ func levelOrderBottom(_ root: TreeNode?) -> [[Int]] {
 }
 ```
 
-
-Scala:
+#### Scala:
 
 ```scala
 // 107.二叉树的层次遍历II
@@ -764,7 +764,10 @@ object Solution {
     res.reverse.toList
   }
 
-Rust:
+
+```
+
+#### Rust:
 
 ```rust
 use std::cell::RefCell;
@@ -796,7 +799,7 @@ impl Solution {
 }
 ```
 
-# 199.二叉树的右视图
+## 199.二叉树的右视图
 
 [力扣题目链接](https://leetcode.cn/problems/binary-tree-right-side-view/)
 
@@ -804,7 +807,7 @@ impl Solution {
 
 ![199.二叉树的右视图](https://code-thinking-1253855093.file.myqcloud.com/pics/20210203151307377.png)
 
-思路：
+### 思路
 
 层序遍历的时候，判断是否遍历到单层的最后面的元素，如果是，就放进result数组中，随后返回result就可以了。
 
@@ -832,7 +835,9 @@ public:
 };
 ```
 
-python代码：
+### 其他语言版本
+
+#### Python：
 
 ```python
 # Definition for a binary tree node.
@@ -866,8 +871,7 @@ class Solution:
         return right_view
 ```
 
-
-Java:
+#### Java:
 
 ```java
 // 199.二叉树的右视图
@@ -911,7 +915,7 @@ public class N0199 {
 }
 ```
 
-go:
+#### Go:
 
 ```GO
 /**
@@ -945,8 +949,7 @@ func rightSideView(root *TreeNode) []int {
 }
 ```
 
-
-javascript代码:
+#### Javascript:
 
 ```javascript
 var rightSideView = function(root) {
@@ -972,7 +975,7 @@ var rightSideView = function(root) {
 };
 ```
 
-TypeScript：
+#### TypeScript：
 
 ```typescript
 function rightSideView(root: TreeNode | null): number[] {
@@ -992,7 +995,7 @@ function rightSideView(root: TreeNode | null): number[] {
 };
 ```
 
-Swift：
+#### Swift：
 
 ```swift
 func rightSideView(_ root: TreeNode?) -> [Int] {
@@ -1017,7 +1020,7 @@ func rightSideView(_ root: TreeNode?) -> [Int] {
 }
 ```
 
-Scala:
+#### Scala:
 
 ```scala
 // 199.二叉树的右视图
@@ -1043,7 +1046,7 @@ object Solution {
 }
 ```
 
-rust:
+#### Rust:
 
 ```rust
 use std::cell::RefCell;
@@ -1076,7 +1079,7 @@ impl Solution {
 }
 ```
 
-# 637.二叉树的层平均值
+## 637.二叉树的层平均值
 
 [力扣题目链接](https://leetcode.cn/problems/average-of-levels-in-binary-tree/)
 
@@ -1084,7 +1087,7 @@ impl Solution {
 
 ![637.二叉树的层平均值](https://code-thinking-1253855093.file.myqcloud.com/pics/20210203151350500.png)
 
-思路:
+### 思路
 
 本题就是层序遍历的时候把一层求个总和在取一个均值。
 
@@ -1115,7 +1118,9 @@ public:
 
 ```
 
-python代码：
+### 其他语言版本
+
+#### Python：
 
 ```python
 class Solution:
@@ -1155,7 +1160,7 @@ class Solution:
         return averages
 ```
 
-java:
+#### Java:
 
 ```java
 // 637. 二叉树的层平均值
@@ -1197,7 +1202,7 @@ public class N0637 {
 }
 ```
 
-go:
+#### Go:
 
 ```GO
 /**
@@ -1235,7 +1240,7 @@ func averageOfLevels(root *TreeNode) []float64 {
 }
 ```
 
-javascript代码：
+#### Javascript：
 
 ```javascript
 var averageOfLevels = function(root) {
@@ -1262,7 +1267,7 @@ var averageOfLevels = function(root) {
 };
 ```
 
-TypeScript：
+#### TypeScript：
 
 ```typescript
 function averageOfLevels(root: TreeNode | null): number[] {
@@ -1286,7 +1291,7 @@ function averageOfLevels(root: TreeNode | null): number[] {
 };
 ```
 
-Swift：
+#### Swift：
 
 ```swift
 func averageOfLevels(_ root: TreeNode?) -> [Double] {
@@ -1313,7 +1318,7 @@ func averageOfLevels(_ root: TreeNode?) -> [Double] {
 }
 ```
 
-Scala:
+#### Scala:
 
 ```scala
 // 637.二叉树的层平均值
@@ -1339,7 +1344,7 @@ object Solution {
 }
 ```
 
-rust:
+#### Rust:
 
 ```rust
 use std::cell::RefCell;
@@ -1372,7 +1377,7 @@ impl Solution {
 }
 ```
 
-# 429.N叉树的层序遍历
+## 429.N叉树的层序遍历
 
 [力扣题目链接](https://leetcode.cn/problems/n-ary-tree-level-order-traversal/)
 
@@ -1390,8 +1395,7 @@ impl Solution {
      [5,6]
 ]
 
-
-思路:
+### 思路
 
 这道题依旧是模板题，只不过一个节点有多个孩子了
 
@@ -1423,7 +1427,9 @@ public:
 };
 ```
 
-python代码：
+### 其他语言版本
+
+#### Python：
 
 ```python
 """
@@ -1475,7 +1481,7 @@ class Solution:
         return result
 ```
 
-java:
+#### Java:
 
 ```java
 // 429. N 叉树的层序遍历
@@ -1535,8 +1541,7 @@ public class N0429 {
 }
 ```
 
-
-go:
+#### Go:
 
 ```GO
 /**
@@ -1567,7 +1572,7 @@ func levelOrder(root *Node) [][]int {
 }
 ```
 
-JavaScript代码：
+#### JavaScript：
 
 ```JavaScript
 var levelOrder = function(root) {
@@ -1596,7 +1601,7 @@ var levelOrder = function(root) {
 };
 ```
 
-TypeScript:
+#### TypeScript:
 
 ```typescript
 function levelOrder(root: Node | null): number[][] {
@@ -1618,7 +1623,7 @@ function levelOrder(root: Node | null): number[][] {
 };
 ```
 
-Swift：
+#### Swift：
 
 ```swift
 func levelOrder(_ root: Node?) -> [[Int]] {
@@ -1643,7 +1648,7 @@ func levelOrder(_ root: Node?) -> [[Int]] {
 }
 ```
 
-Scala:
+#### Scala:
 
 ```scala
 // 429.N叉树的层序遍历
@@ -1672,7 +1677,7 @@ object Solution {
 }
 ```
 
-rust:
+#### Rust:
 
 ```rust
 pub struct Solution;
@@ -1720,7 +1725,7 @@ impl Solution {
 }
 ```
 
-# 515.在每个树行中找最大值
+## 515.在每个树行中找最大值
 
 [力扣题目链接](https://leetcode.cn/problems/find-largest-value-in-each-tree-row/)
 
@@ -1728,7 +1733,7 @@ impl Solution {
 
 ![515.在每个树行中找最大值](https://code-thinking-1253855093.file.myqcloud.com/pics/20210203151532153.png)
 
-思路：
+### 思路
 
 层序遍历，取每一层的最大值
 
@@ -1758,7 +1763,9 @@ public:
 };
 ```
 
-python代码：
+### 其他语言版本
+
+#### Python：
 
 ```python
 # Definition for a binary tree node.
@@ -1794,7 +1801,7 @@ class Solution:
         return result
 ```
 
-java代码：
+#### Java：
 
 ```java
 class Solution {
@@ -1820,7 +1827,7 @@ class Solution {
 }
 ```
 
-go:
+#### Go:
 
 ```GO
 /**
@@ -1864,7 +1871,7 @@ func max(x, y int) int {
 }
 ```
 
-javascript代码：
+#### Javascript：
 
 ```javascript
 var largestValues = function(root) {
@@ -1890,7 +1897,7 @@ var largestValues = function(root) {
 };
 ```
 
-TypeScript:
+#### TypeScript:
 
 ```typescript
 function largestValues(root: TreeNode | null): number[] {
@@ -1916,7 +1923,7 @@ function largestValues(root: TreeNode | null): number[] {
 };
 ```
 
-Swift：
+#### Swift：
 
 ```swift
 func largestValues(_ root: TreeNode?) -> [Int] {
@@ -1943,7 +1950,7 @@ func largestValues(_ root: TreeNode?) -> [Int] {
 }
 ```
 
-Scala:
+#### Scala:
 
 ```scala
 // 515.在每个树行中找最大值
@@ -1970,7 +1977,7 @@ object Solution {
 }
 ```
 
-rust:
+#### Rust:
 
 ```rust
 use std::cell::RefCell;
@@ -2002,7 +2009,7 @@ impl Solution {
 }
 ```
 
-# 116.填充每个节点的下一个右侧节点指针
+## 116.填充每个节点的下一个右侧节点指针
 
 [力扣题目链接](https://leetcode.cn/problems/populating-next-right-pointers-in-each-node/)
 
@@ -2024,7 +2031,7 @@ struct Node {
 
 ![116.填充每个节点的下一个右侧节点指针](https://code-thinking-1253855093.file.myqcloud.com/pics/20210203152044855.jpg)
 
-思路:
+### 思路
 
 本题依然是层序遍历，只不过在单层遍历的时候记录一下本层的头部节点，然后在遍历的时候让前一个节点指向本节点就可以了
 
@@ -2063,7 +2070,9 @@ public:
 };
 ```
 
-java代码：
+### 其他语言版本
+
+#### Java：
 
 ```java
 class Solution {
@@ -2093,7 +2102,7 @@ class Solution {
 }
 ```
 
-python代码：
+#### Python：
 
 ```python
 """
@@ -2133,7 +2142,7 @@ class Solution:
         return root
 ```
 
-go:
+#### Go:
 
 ```GO
 /**
@@ -2173,7 +2182,7 @@ func connect(root *Node) *Node {
 
 ```
 
-JavaScript:
+#### JavaScript:
 
 ```javascript
 /**
@@ -2209,7 +2218,7 @@ var connect = function(root) {
 
 ```
 
-TypeScript:
+#### TypeScript:
 
 ```typescript
 function connect(root: Node | null): Node | null {
@@ -2234,7 +2243,7 @@ function connect(root: Node | null): Node | null {
 };
 ```
 
-Swift：
+#### Swift：
 
 ```swift
 func connect(_ root: Node?) -> Node? {
@@ -2266,7 +2275,7 @@ func connect(_ root: Node?) -> Node? {
 }
 ```
 
-Scala:
+#### Scala:
 
 ```scala
 // 116.填充每个节点的下一个右侧节点指针
@@ -2297,11 +2306,11 @@ object Solution {
 }
 ```
 
-# 117.填充每个节点的下一个右侧节点指针II
+## 117.填充每个节点的下一个右侧节点指针II
 
 [力扣题目链接](https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii/)
 
-思路：
+### 思路
 
 这道题目说是二叉树，但116题目说是完整二叉树，其实没有任何差别，一样的代码一样的逻辑一样的味道
 
@@ -2339,7 +2348,9 @@ public:
 };
 ```
 
-Java 代码：
+### 其他语言版本
+
+#### Java：
 
 ```java
 // 二叉树之层次遍历
@@ -2377,7 +2388,7 @@ class Solution {
 }
 ```
 
-python代码：
+#### Python：
 
 ```python
 # 层序遍历解法
@@ -2420,7 +2431,7 @@ class Solution:
 
 ```
 
-go:
+#### Go:
 
 ```GO
 /**
@@ -2459,7 +2470,7 @@ func connect(root *Node) *Node {
 }
 ```
 
-JavaScript:
+#### JavaScript:
 
 ```javascript
 /**
@@ -2494,7 +2505,7 @@ var connect = function(root) {
 };
 ```
 
-TypeScript:
+#### TypeScript:
 
 ```typescript
 function connect(root: Node | null): Node | null {
@@ -2519,7 +2530,7 @@ function connect(root: Node | null): Node | null {
 };
 ```
 
-Swift：
+#### Swift：
 
 ```swift
 func connect(_ root: Node?) -> Node? {
@@ -2551,7 +2562,7 @@ func connect(_ root: Node?) -> Node? {
 }
 ```
 
-Scala:
+#### Scala:
 
 ```scala
 // 117.填充每个节点的下一个右侧节点指针II
@@ -2582,7 +2593,7 @@ object Solution {
 }
 ```
 
-# 104.二叉树的最大深度
+## 104.二叉树的最大深度
 
 [力扣题目链接](https://leetcode.cn/problems/maximum-depth-of-binary-tree/)
 
@@ -2600,7 +2611,7 @@ object Solution {
 
 返回它的最大深度 3 。
 
-思路：
+### 思路
 
 使用迭代法的话，使用层序遍历是最为合适的，因为最大的深度就是二叉树的层数，和层序遍历的方式极其吻合。
 
@@ -2635,7 +2646,9 @@ public:
 };
 ```
 
-Java：
+### 其他语言版本
+
+#### Java：
 
 ```Java
 class Solution {
@@ -2661,7 +2674,7 @@ class Solution {
 }
 ```
 
-Python：
+#### Python：
 
 ```python 3
 # Definition for a binary tree node.
@@ -2691,7 +2704,7 @@ class Solution:
 
 ```
 
-Go：
+#### Go：
 
 ```go
 /**
@@ -2726,7 +2739,7 @@ func maxDepth(root *TreeNode) int {
 }
 ```
 
-JavaScript：
+#### JavaScript：
 
 ```javascript
 /**
@@ -2759,7 +2772,7 @@ var maxDepth = function(root) {
 };
 ```
 
-TypeScript:
+#### TypeScript:
 
 ```typescript
 function maxDepth(root: TreeNode | null): number {
@@ -2779,7 +2792,7 @@ function maxDepth(root: TreeNode | null): number {
 };
 ```
 
-Swift：
+#### Swift：
 
 ```swift
 func maxDepth(_ root: TreeNode?) -> Int {
@@ -2804,7 +2817,7 @@ func maxDepth(_ root: TreeNode?) -> Int {
 }
 ```
 
-Scala:
+#### Scala:
 
 ```scala
 // 104.二叉树的最大深度
@@ -2829,7 +2842,7 @@ object Solution {
 }
 ```
 
-rust:
+#### Rust:
 
 ```rust
 use std::cell::RefCell;
@@ -2859,10 +2872,12 @@ impl Solution {
 }
 ```
 
-# 111.二叉树的最小深度
+## 111.二叉树的最小深度
 
 [力扣题目链接](https://leetcode.cn/problems/minimum-depth-of-binary-tree/)
 
+### 思路
+
 相对于 104.二叉树的最大深度 ，本题还也可以使用层序遍历的方式来解决，思路是一样的。
 
 **需要注意的是，只有当左右孩子都为空的时候，才说明遍历的最低点了。如果其中一个孩子为空则不是最低点**
@@ -2895,7 +2910,9 @@ public:
 };
 ```
 
-Java：
+### 其他语言版本
+
+#### Java：
 
 ```java
 class Solution {
@@ -2925,9 +2942,7 @@ class Solution {
 }
 ```
 
-
-
-Python 3：
+#### Python：
 
 ```python 3
 # Definition for a binary tree node.
@@ -2960,7 +2975,7 @@ class Solution:
         return depth
 ```
 
-Go：
+#### Go：
 
 ```go
 /**
@@ -2999,7 +3014,7 @@ func minDepth(root *TreeNode) int {
 }
 ```
 
-JavaScript：
+#### JavaScript：
 
 ```javascript
 /**
@@ -3035,7 +3050,7 @@ var minDepth = function(root) {
 };
 ```
 
-TypeScript:
+#### TypeScript:
 
 ```typescript
 function minDepth(root: TreeNode | null): number {
@@ -3056,7 +3071,7 @@ function minDepth(root: TreeNode | null): number {
 };
 ```
 
-Swift：
+#### Swift：
 
 ```swift
 func minDepth(_ root: TreeNode?) -> Int {
@@ -3082,7 +3097,7 @@ func minDepth(_ root: TreeNode?) -> Int {
 }
 ```
 
-Scala:
+#### Scala:
 
 ```scala
 // 111.二叉树的最小深度
@@ -3108,7 +3123,7 @@ object Solution {
 }
 ```
 
-rust:
+#### Rust:
 
 ```rust
 use std::cell::RefCell;
@@ -3141,28 +3156,27 @@ impl Solution {
 }
 ```
 
-# 总结
+## 总结
 
 二叉树的层序遍历，**就是图论中的广度优先搜索在二叉树中的应用**，需要借助队列来实现（此时又发现队列的一个应用了）。
 
 来吧，一口气打十个：
 
-* 102.二叉树的层序遍历
-* 107.二叉树的层次遍历II
-* 199.二叉树的右视图
-* 637.二叉树的层平均值
-* 429.N叉树的层序遍历
-* 515.在每个树行中找最大值
-* 116.填充每个节点的下一个右侧节点指针
-* 117.填充每个节点的下一个右侧节点指针II
-* 104.二叉树的最大深度
-* 111.二叉树的最小深度
+* [102.二叉树的层序遍历](https://leetcode.cn/problems/binary-tree-level-order-traversal/)
+* [107.二叉树的层次遍历II](https://leetcode.cn/problems/binary-tree-level-order-traversal-ii/)
+* [199.二叉树的右视图](https://leetcode.cn/problems/binary-tree-right-side-view/)
+* [637.二叉树的层平均值](https://leetcode.cn/problems/binary-tree-right-side-view/)
+* [429.N叉树的层序遍历](https://leetcode.cn/problems/n-ary-tree-level-order-traversal/)
+* [515.在每个树行中找最大值](https://leetcode.cn/problems/find-largest-value-in-each-tree-row/)
+* [116.填充每个节点的下一个右侧节点指针](https://leetcode.cn/problems/populating-next-right-pointers-in-each-node/)
+* [117.填充每个节点的下一个右侧节点指针II](https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii/)
+* [104.二叉树的最大深度](https://leetcode.cn/problems/maximum-depth-of-binary-tree/)
+* [111.二叉树的最小深度](https://leetcode.cn/problems/minimum-depth-of-binary-tree/)
 
 **致敬叶师傅！**
 
-
-
 <p align="center">
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
 </a>
+
diff --git a/problems/0104.二叉树的最大深度.md b/problems/0104.二叉树的最大深度.md
index 7130867b..05044375 100644
--- a/problems/0104.二叉树的最大深度.md
+++ b/problems/0104.二叉树的最大深度.md
@@ -5,6 +5,7 @@
 <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
 
 
+
 # 104.二叉树的最大深度
 
 [力扣题目链接](https://leetcode.cn/problems/maximum-depth-of-binary-tree/)
@@ -23,17 +24,19 @@
 
 返回它的最大深度 3 。
 
-# 思路 
+## 算法公开课
+
+**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[二叉树的高度和深度有啥区别？究竟用什么遍历顺序？很多录友搞不懂 | 104.二叉树的最大深度](https://www.bilibili.com/video/BV1Gd4y1V75u)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
+
+## 思路 
 
 看完本篇可以一起做了如下两道题目：
 
-* 104.二叉树的最大深度
-* 559.n叉树的最大深度
-
-《代码随想录》算法视频公开课：[二叉树的高度和深度有啥区别？究竟用什么遍历顺序？很多录友搞不懂 | 104.二叉树的最大深度](https://www.bilibili.com/video/BV1Gd4y1V75u)，相信结合视频在看本篇题解，更有助于大家对本题的理解。
+* [104.二叉树的最大深度](https://leetcode.cn/problems/maximum-depth-of-binary-tree/)
+* [559.n叉树的最大深度](https://leetcode.cn/problems/maximum-depth-of-n-ary-tree/)
 
 
-## 递归法
+### 递归法
 
 本题可以使用前序（中左右），也可以使用后序遍历（左右中），使用前序求的就是深度，使用后序求的是高度。
 
@@ -164,7 +167,7 @@ public:
 };
 ```
 
-## 迭代法
+### 迭代法
 
 使用迭代法的话，使用层序遍历是最为合适的，因为最大的深度就是二叉树的层数，和层序遍历的方式极其吻合。
 
@@ -202,10 +205,11 @@ public:
 };
 ```
 
-
 那么我们可以顺便解决一下n叉树的最大深度问题
 
-# 559.n叉树的最大深度
+## 相关题目推荐
+
+### 559.n叉树的最大深度
 
 [力扣题目链接](https://leetcode.cn/problems/maximum-depth-of-n-ary-tree/)
 
@@ -219,11 +223,11 @@ public:
 
 我们应返回其最大深度，3。
 
-思路：
+### 思路
 
 依然可以提供递归法和迭代法，来解决这个问题，思路是和二叉树思路一样的，直接给出代码如下：
 
-## 递归法
+#### 递归法
 
 c++代码：
 
@@ -240,7 +244,7 @@ public:
     }
 };
 ```
-## 迭代法
+#### 迭代法
 
 依然是层序遍历，代码如下：
 
@@ -267,11 +271,11 @@ public:
 };
 ```
 
-# 其他语言版本
+## 其他语言版本
 
-## java
+### Java:
 
-### 104.二叉树的最大深度
+104.二叉树的最大深度
 
 ```java
 class solution {
@@ -344,7 +348,8 @@ class solution {
 }
 ```
 
-### 559.n叉树的最大深度 
+559.n叉树的最大深度 
+
 ```java
 class Solution {
     /*递归法，后序遍历求root节点的高度*/
@@ -391,9 +396,9 @@ class solution {
 }
 ```
 
-## python 
+### Python :
 
-### 104.二叉树的最大深度
+104.二叉树的最大深度
 
 递归法：
 ```python
@@ -448,7 +453,7 @@ class Solution:
 
 ```
 
-### 559.n叉树的最大深度 
+559.n叉树的最大深度 
 
 递归法：
 ```python
@@ -522,9 +527,10 @@ class Solution:
         return max_depth
 ```
 
+### Go:
+
+104.二叉树的最大深度
 
-## go 
-### 104.二叉树的最大深度
 ```go
 /**
  * definition for a binary tree node.
@@ -574,7 +580,7 @@ func maxdepth(root *treenode) int {
 
 ```
 
-### 559. n叉树的最大深度
+559. n叉树的最大深度
 
 ```go
 func maxDepth(root *Node) int {
@@ -598,9 +604,9 @@ func maxDepth(root *Node) int {
 }
 ```
 
-## javascript 
+### Javascript :
 
-### 104.二叉树的最大深度
+104.二叉树的最大深度
 
 ```javascript
 var maxdepth = function(root) {
@@ -649,7 +655,7 @@ var maxDepth = function(root) {
 };
 ```
 
-### 559.n叉树的最大深度
+559.n叉树的最大深度
 
 N叉树的最大深度  递归写法
 ```js
@@ -683,9 +689,9 @@ var maxDepth = function(root) {
 };
 ```
 
-## TypeScript
+### TypeScript:
 
-### 104.二叉树的最大深度
+104.二叉树的最大深度
 
 ```typescript
 // 后续遍历（自下而上）
@@ -728,7 +734,7 @@ function maxDepth(root: TreeNode | null): number {
 };
 ```
 
-### 559.n叉树的最大深度
+559.n叉树的最大深度
 
 ```typescript
 // 后续遍历（自下而上）
@@ -756,9 +762,9 @@ function maxDepth(root: TreeNode | null): number {
 
 ```
 
-## C
+### C:
 
-### 104.二叉树的最大深度
+104.二叉树的最大深度
 
 二叉树最大深度递归
 ```c
@@ -814,9 +820,9 @@ int maxDepth(struct TreeNode* root){
 }
 ```
 
-## Swift
+### Swift:
 
-### 104.二叉树的最大深度
+104.二叉树的最大深度
 
 ```swift
 // 递归 - 后序
@@ -856,7 +862,7 @@ func maxDepth(_ root: TreeNode?) -> Int {
 }
 ```
 
-### 559.n叉树的最大深度
+559.n叉树的最大深度
 
 ```swift
 // 递归
@@ -893,9 +899,10 @@ func maxDepth1(_ root: Node?) -> Int {
 }
 ```
 
-## Scala
+### Scala:
+
+104.二叉树的最大深度
 
-### 104.二叉树的最大深度
 递归法:
 ```scala
 object Solution {
@@ -934,7 +941,7 @@ object Solution {
 }
 ```
 
-### 559.n叉树的最大深度
+559.n叉树的最大深度
 
 递归法:
 ```scala
@@ -972,8 +979,8 @@ object Solution {
 }
 ```
 
-## rust
-### 0104.二叉树的最大深度
+### Rust:
+0104.二叉树的最大深度
 
 递归：
 ```rust
diff --git a/problems/0110.平衡二叉树.md b/problems/0110.平衡二叉树.md
index e10a612a..c7df9c8f 100644
--- a/problems/0110.平衡二叉树.md
+++ b/problems/0110.平衡二叉树.md
@@ -33,8 +33,9 @@
 
 返回 false 。
 
+## 算法公开课
 
-**《代码随想录》算法视频公开课：[后序遍历求高度，高度判断是否平衡 | LeetCode：110.平衡二叉树](https://www.bilibili.com/video/BV1Ug411S7my)，相信结合视频在看本篇题解，更有助于大家对本题的理解**。
+**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[后序遍历求高度，高度判断是否平衡 | LeetCode：110.平衡二叉树](https://www.bilibili.com/video/BV1Ug411S7my)，相信结合视频在看本篇题解，更有助于大家对本题的理解**。
 
 ## 题外话
 
@@ -357,7 +358,7 @@ public:
 
 ## 其他语言版本
 
-### Java
+### Java:
 
 ```Java
 class Solution {
@@ -498,7 +499,7 @@ class Solution {
 }
 ```
 
-### Python
+### Python:
 
 递归法：
 
@@ -620,7 +621,7 @@ class Solution:
                 height_map[real_node] = 1 + max(left, right)
         return True
 ```
-### Go
+### Go:
 
 ```Go
 func isBalanced(root *TreeNode) bool {
@@ -652,7 +653,7 @@ func max(a, b int) int {
 }
 ```
 
-### JavaScript
+### JavaScript:
 
 递归法：
 
@@ -723,7 +724,7 @@ var isBalanced = function (root) {
 };
 ```
 
-### TypeScript
+### TypeScript:
 
 ```typescript
 // 递归法
@@ -741,7 +742,7 @@ function isBalanced(root: TreeNode | null): boolean {
 };
 ```
 
-### C
+### C:
 
 递归法：
 
@@ -876,7 +877,7 @@ func getHeight(_ root: TreeNode?) -> Int {
 }
 ```
 
-### rust
+### Rust:
 
 递归
 
@@ -912,3 +913,4 @@ impl Solution {
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
 </a>
+
diff --git a/problems/0111.二叉树的最小深度.md b/problems/0111.二叉树的最小深度.md
index a1fc8a93..61f9beb7 100644
--- a/problems/0111.二叉树的最小深度.md
+++ b/problems/0111.二叉树的最小深度.md
@@ -26,9 +26,11 @@
 
 返回它的最小深度  2.
 
-# 思路
+## 算法公开课
 
-《代码随想录》算法视频公开课：[看起来好像做过，一写就错！ | LeetCode：111.二叉树的最小深度](https://www.bilibili.com/video/BV1QD4y1B7e2)，相信结合视频在看本篇题解，更有助于大家对本题的理解。
+**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[看起来好像做过，一写就错！ | LeetCode：111.二叉树的最小深度](https://www.bilibili.com/video/BV1QD4y1B7e2)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
+
+## 思路
 
 
 看完了这篇[104.二叉树的最大深度](https://programmercarl.com/0104.二叉树的最大深度.html)，再来看看如何求最小深度。
@@ -52,7 +54,7 @@
 
 什么是叶子节点，左右孩子都为空的节点才是叶子节点！
 
-## 递归法
+### 递归法
 
 来来来，一起递归三部曲：
 
@@ -199,7 +201,7 @@ public:
 };
 ```
 
-## 迭代法
+### 迭代法
 
 相对于[104.二叉树的最大深度](https://programmercarl.com/0104.二叉树的最大深度.html)，本题还可以使用层序遍历的方式来解决，思路是一样的。
 
@@ -237,10 +239,10 @@ public:
 ```
 
 
-# 其他语言版本
+## 其他语言版本
 
 
-## Java
+### Java:
 
 ```Java
 class Solution {
@@ -300,7 +302,7 @@ class Solution {
 }
 ```
 
-## Python 
+### Python :
 
 递归法（版本一）
 
@@ -400,9 +402,7 @@ class Solution:
         return depth
 ```
 
-
-
-## Go
+### Go:
 
 ```go
 /**
@@ -463,7 +463,7 @@ func minDepth(root *TreeNode) int {
 ```
 
 
-## JavaScript
+### JavaScript:
 
 递归法：
 
@@ -509,7 +509,7 @@ var minDepth = function(root) {
 };
 ```
 
-## TypeScript
+### TypeScript:
 
 > 递归法
 
@@ -547,7 +547,7 @@ function minDepth(root: TreeNode | null): number {
 };
 ```
 
-## Swift
+### Swift:
 
 > 递归
 ```Swift
@@ -594,7 +594,7 @@ func minDepth(_ root: TreeNode?) -> Int {
 ```
 
 
-## Scala
+### Scala:
 
 递归法:
 ```scala
@@ -633,7 +633,8 @@ object Solution {
 }
 ```
 
-rust:
+### Rust:
+
 ```rust
 impl Solution {
     // 递归
diff --git a/problems/0222.完全二叉树的节点个数.md b/problems/0222.完全二叉树的节点个数.md
index 795a6f37..d54f9b85 100644
--- a/problems/0222.完全二叉树的节点个数.md
+++ b/problems/0222.完全二叉树的节点个数.md
@@ -29,14 +29,17 @@
 * 0 <= Node.val <= 5 * 10^4
 * 题目数据保证输入的树是 完全二叉树
 
+## 算法公开课
 
-# 思路
+**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[要理解普通二叉树和完全二叉树的区别！ | LeetCode：222.完全二叉树节点的数量](https://www.bilibili.com/video/BV1eW4y1B7pD)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
+
+
+## 思路
 
-《代码随想录》算法视频公开课：[要理解普通二叉树和完全二叉树的区别！ | LeetCode：222.完全二叉树节点的数量](https://www.bilibili.com/video/BV1eW4y1B7pD)，相信结合视频在看本篇题解，更有助于大家对本题的理解。
 
 本篇给出按照普通二叉树的求法以及利用完全二叉树性质的求法。
 
-## 普通二叉树
+### 普通二叉树
 
 首先按照普通二叉树的逻辑来求。
 
@@ -44,7 +47,7 @@
 
 递归遍历的顺序依然是后序（左右中）。
 
-### 递归
+#### 递归
 
 如果对求二叉树深度还不熟悉的话，看这篇：[二叉树：看看这些树的最大深度](https://programmercarl.com/0104.二叉树的最大深度.html)。
 
@@ -112,7 +115,7 @@ public:
 **网上基本都是这个精简的代码版本，其实不建议大家照着这个来写，代码确实精简，但隐藏了一些内容，连遍历的顺序都看不出来，所以初学者建议学习版本一的代码，稳稳的打基础**。
 
 
-### 迭代法
+#### 迭代
 
 如果对求二叉树层序遍历还不熟悉的话，看这篇：[二叉树：层序遍历登场！](https://programmercarl.com/0102.二叉树的层序遍历.html)。
 
@@ -142,7 +145,7 @@ public:
 * 时间复杂度：O(n)
 * 空间复杂度：O(n)
 
-## 完全二叉树
+### 完全二叉树
 
 以上方法都是按照普通二叉树来做的，对于完全二叉树特性不了解的同学可以看这篇 [关于二叉树，你该了解这些！](https://programmercarl.com/二叉树理论基础.html)，这篇详细介绍了各种二叉树的特性。
 
@@ -249,9 +252,9 @@ public:
 * 时间复杂度：O(log n × log n)
 * 空间复杂度：O(log n)
 
-# 其他语言版本
+## 其他语言版本
 
-## Java
+### Java:
 ```java
 class Solution {
     // 通用递归解法
@@ -312,7 +315,7 @@ class Solution {
 }
 ```
 
-## Python
+### Python:
 
 递归法：
 ```python
@@ -408,7 +411,7 @@ class Solution: # 利用完全二叉树特性
         return 1+self.countNodes(root.left)+self.countNodes(root.right)  
 ```
 
-## Go
+### Go:
 
 递归版本
 
@@ -488,9 +491,7 @@ func countNodes(root *TreeNode) int {
 }
 ```
 
-
-
-## JavaScript:
+### JavaScript:
 
 递归版本
 ```javascript
@@ -559,7 +560,7 @@ var countNodes = function(root) {
 };
 ```
 
-## TypeScrpt:
+### TypeScrpt:
 
 > 递归法
 
@@ -614,7 +615,7 @@ function countNodes(root: TreeNode | null): number {
 };
 ```
 
-## C:
+### C:
 
 递归法
 ```c
@@ -690,7 +691,7 @@ int countNodes(struct TreeNode* root){
 }
 ```
 
-## Swift:
+### Swift:
 
 > 递归
 ```swift
@@ -758,7 +759,7 @@ func countNodes(_ root: TreeNode?) -> Int {
 }
 ```
 
-## Scala
+### Scala:
 
 递归:
 ```scala
@@ -821,9 +822,9 @@ object Solution {
 }
 ```
 
-rust:
+### Rust:
 
-// 递归
+递归
 ```rust
 use std::cell::RefCell;
 use std::rc::Rc;
@@ -838,7 +839,7 @@ impl Solution {
 }
 ```
 
-// 迭代
+迭代
 ```rust
 use std::rc::Rc;
 use std::cell::RefCell;
diff --git a/problems/0226.翻转二叉树.md b/problems/0226.翻转二叉树.md
index b3aea9ed..11517783 100644
--- a/problems/0226.翻转二叉树.md
+++ b/problems/0226.翻转二叉树.md
@@ -16,7 +16,11 @@
 
 这道题目背后有一个让程序员心酸的故事，听说 Homebrew的作者Max Howell，就是因为没在白板上写出翻转二叉树，最后被Google拒绝了。（真假不做判断，权当一个乐子哈）
 
-# 题外话
+## 算法公开课
+
+**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[听说一位巨佬面Google被拒了，因为没写出翻转二叉树 | LeetCode：226.翻转二叉树](https://www.bilibili.com/video/BV1sP4y1f7q7)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
+
+## 题外话
 
 这道题目是非常经典的题目，也是比较简单的题目（至少一看就会）。
 
@@ -24,9 +28,7 @@
 
 如果做过这道题的同学也建议认真看完，相信一定有所收获！
 
-# 思路
-
-《代码随想录》算法视频公开课：[听说一位巨佬面Google被拒了，因为没写出翻转二叉树 | LeetCode：226.翻转二叉树](https://www.bilibili.com/video/BV1sP4y1f7q7)，相信结合视频在看本篇题解，更有助于大家对本题的理解。
+## 思路
 
 我们之前介绍的都是各种方式遍历二叉树，这次要翻转了，感觉还是有点懵逼。
 
@@ -49,7 +51,7 @@
 
 那么层序遍历可以不可以呢？**依然可以的！只要把每一个节点的左右孩子翻转一下的遍历方式都是可以的！**
 
-## 递归法
+### 递归法
 
 对于二叉树的递归法的前中后序遍历，已经在[二叉树：前中后序递归遍历](https://programmercarl.com/二叉树的递归遍历.html)详细讲解了。
 
@@ -102,9 +104,9 @@ public:
 };
 ```
 
-## 迭代法
+### 迭代法
 
-### 深度优先遍历
+#### 深度优先遍历
 
 [二叉树：听说递归能做的，栈也能做！](https://programmercarl.com/二叉树的迭代遍历.html)中给出了前中后序迭代方式的写法，所以本题可以很轻松的写出如下迭代法的代码：
 
@@ -163,7 +165,7 @@ public:
 
 如果上面这个代码看不懂，回顾一下文章[二叉树：前中后序迭代方式的统一写法](https://programmercarl.com/二叉树的统一迭代法.html)。
 
-### 广度优先遍历
+#### 广度优先遍历
 
 也就是层序遍历，层数遍历也是可以翻转这棵树的，因为层序遍历也可以把每个节点的左右孩子都翻转一遍，代码如下：
 
@@ -259,7 +261,7 @@ public:
 ## 其他语言版本
 
 
-### Java
+### Java:
 ```Java
 //DFS递归
 class Solution {
@@ -310,7 +312,7 @@ class Solution {
 }
 ```
 
-### Python
+### Python:
 
 递归法：前序遍历：
 ```python
@@ -466,7 +468,7 @@ class Solution:
 
 ```
 
-### Go
+### Go:
 
 递归版本的前序遍历
 ```Go
@@ -575,7 +577,7 @@ func invertTree(root *TreeNode) *TreeNode {
 }
 ```
 
-### JavaScript
+### JavaScript:
 
 使用递归版本的前序遍历
 ```javascript
@@ -783,7 +785,7 @@ function invertTree(root: TreeNode | null): TreeNode | null {
 };
 ```
 
-### C
+### C:
 
 递归法
 ```c
@@ -961,7 +963,7 @@ object Solution {
 }
 ```
 
-### rust
+### Rust:
 
 ```rust
 impl Solution {
@@ -991,7 +993,7 @@ impl Solution {
 }
 ```
 
-### C#
+### C#:
 
 ```csharp
 //递归
@@ -1042,3 +1044,4 @@ public class Solution {
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
 </a>
+
diff --git a/problems/0257.二叉树的所有路径.md b/problems/0257.二叉树的所有路径.md
index 06153507..44c0fd85 100644
--- a/problems/0257.二叉树的所有路径.md
+++ b/problems/0257.二叉树的所有路径.md
@@ -18,9 +18,11 @@
 示例:
 ![257.二叉树的所有路径1](https://code-thinking-1253855093.file.myqcloud.com/pics/2021020415161576.png)
 
-# 思路
+## 算法公开课
 
-**《代码随想录》算法视频公开课：[递归中带着回溯，你感受到了没？| LeetCode：257. 二叉树的所有路径](https://www.bilibili.com/video/BV1ZG411G7Dh)，相信结合视频在看本篇题解，更有助于大家对本题的理解**。
+**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：：[递归中带着回溯，你感受到了没？| LeetCode：257. 二叉树的所有路径](https://www.bilibili.com/video/BV1ZG411G7Dh)，相信结合视频在看本篇题解，更有助于大家对本题的理解**。
+
+## 思路
 
 这道题目要求从根节点到叶子的路径，所以需要前序遍历，这样才方便让父节点指向孩子节点，找到对应的路径。
 
@@ -32,7 +34,7 @@
 
 我们先使用递归的方式，来做前序遍历。**要知道递归和回溯就是一家的，本题也需要回溯。**
 
-## 递归
+### 递归
 
 1. 递归函数参数以及返回值
 
@@ -305,7 +307,7 @@ public:
 
 **综合以上，第二种递归的代码虽然精简但把很多重要的点隐藏在了代码细节里，第一种递归写法虽然代码多一些，但是把每一个逻辑处理都完整的展现出来了。**
 
-## 拓展 
+### 拓展 
 
 这里讲解本题解的写法逻辑以及一些更具体的细节，下面的讲解中，涉及到C++语法特性，如果不是C++的录友，就可以不看了，避免越看越晕。 
 
@@ -328,7 +330,7 @@ public:
 所以，第一个代码版本中，我才使用 vector 类型的path，这样方便给大家演示代码中回溯的操作。 vector类型的path，不管 每次 路径收集的数字是几位数，总之一定是int，所以就一次 pop_back就可以。 
 
 
-## 迭代法
+### 迭代法
 
 
 至于非递归的方式，我们可以依然可以使用前序遍历的迭代方式来模拟遍历路径的过程，对该迭代方式不了解的同学，可以看文章[二叉树：听说递归能做的，栈也能做！](https://programmercarl.com/二叉树的迭代遍历.html)和[二叉树：前中后序迭代方式统一写法](https://programmercarl.com/二叉树的统一迭代法.html)。
@@ -368,7 +370,7 @@ public:
 ```
 当然，使用java的同学，可以直接定义一个成员变量为object的栈`Stack<Object> stack = new Stack<>();`，这样就不用定义两个栈了，都放到一个栈里就可以了。
 
-# 总结
+## 总结
 
 **本文我们开始初步涉及到了回溯，很多同学过了这道题目，可能都不知道自己其实使用了回溯，回溯和递归都是相伴相生的。**
 
@@ -380,13 +382,9 @@ public:
 
 对于本题充分了解递归与回溯的过程之后，有精力的同学可以再去实现迭代法。
 
+## 其他语言版本
 
-
-
-
-# 其他语言版本
-
-## Java：
+### Java：
 
 ```Java
 //解法一
@@ -492,9 +490,9 @@ class Solution {
 }
 ```
 ---
-## Python:  
-	
-	
+### Python:  
+
+
 递归法+回溯
 ```Python
 # Definition for a binary tree node.
@@ -552,7 +550,7 @@ class Solution:
             self.traversal(cur.right, path[:], result)
 
 ```
-	
+
 递归法+隐形回溯（版本二）
 ```Python
 # Definition for a binary tree node.
@@ -610,7 +608,7 @@ class Solution:
 
 ---
 
-## Go：
+### Go：
 
 递归法：
 
@@ -672,7 +670,7 @@ func binaryTreePaths(root *TreeNode) []string {
 ```
 
 ---
-## JavaScript:
+### JavaScript:
 
 递归法：
 
@@ -725,7 +723,7 @@ var binaryTreePaths = function(root) {
 };  
 ```
 
-## TypeScript：
+### TypeScript：
 
 > 递归法
 
@@ -779,7 +777,7 @@ function binaryTreePaths(root: TreeNode | null): string[] {
 };
 ```
 
-## Swift:
+### Swift:
 
 > 递归/回溯
 ```swift
@@ -846,7 +844,7 @@ func binaryTreePaths(_ root: TreeNode?) -> [String] {
 }
 ```
 
-## Scala:
+### Scala:
 
 递归:
 ```scala
@@ -876,7 +874,7 @@ object Solution {
 }
 ```
 
-rust:
+### Rust:
 
 ```rust
 // 递归
@@ -907,4 +905,3 @@ impl Solution {
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
 </a>
-
diff --git a/problems/二叉树理论基础.md b/problems/二叉树理论基础.md
index 4098cf1f..184dba60 100644
--- a/problems/二叉树理论基础.md
+++ b/problems/二叉树理论基础.md
@@ -8,8 +8,11 @@
 
 # 二叉树理论基础篇
 
+## 算法公开课
 
-《代码随想录》算法视频公开课：[关于二叉树，你该了解这些！](https://www.bilibili.com/video/BV1Hy4y1t7ij)，相信结合视频在看本篇题解，更有助于大家对本题的理解。
+**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[关于二叉树，你该了解这些！](https://www.bilibili.com/video/BV1Hy4y1t7ij)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
+
+## 题目分类
 
 
 题目分类大纲如下：
@@ -189,8 +192,7 @@ struct TreeNode {
 
 ## 其他语言版本
 
-
-Java：
+### Java：
 
 ```java
 public class TreeNode {
@@ -208,8 +210,7 @@ public class TreeNode {
 }
 ```
 
-
-Python：
+### Python：
 
 ```python
 class TreeNode:
@@ -219,7 +220,7 @@ class TreeNode:
         self.right = right
 ```
 
-Go：
+### Go：
 
 ```go
 type TreeNode struct {
@@ -229,7 +230,7 @@ type TreeNode struct {
 }
 ```
 
-JavaScript：
+### JavaScript：
 
 ```javascript
 function TreeNode(val, left, right) {
@@ -239,7 +240,7 @@ function TreeNode(val, left, right) {
 }
 ```
 
-TypeScript：
+### TypeScript：
 
 ```typescript
 class TreeNode {
@@ -254,7 +255,7 @@ class TreeNode {
 }
 ```
 
-Swift:
+### Swift:
 
 ```Swift
 class TreeNode<T> {
@@ -271,7 +272,7 @@ class TreeNode<T> {
 }
 ```
 
-Scala:
+### Scala:
 
 ```scala
 class TreeNode(_value: Int = 0, _left: TreeNode = null, _right: TreeNode = null) {
@@ -281,7 +282,7 @@ class TreeNode(_value: Int = 0, _left: TreeNode = null, _right: TreeNode = null)
 }
 ```
 
-rust:
+### Rust:
 
 ```rust
 #[derive(Debug, PartialEq, Eq)]
diff --git a/problems/二叉树的统一迭代法.md b/problems/二叉树的统一迭代法.md
index 27464269..8089af64 100644
--- a/problems/二叉树的统一迭代法.md
+++ b/problems/二叉树的统一迭代法.md
@@ -5,10 +5,11 @@
 <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
 
 
+> 统一写法是一种什么感觉
 
 # 二叉树的统一迭代法
 
-> 统一写法是一种什么感觉
+## 思路
 
 此时我们在[二叉树：一入递归深似海，从此offer是路人](https://programmercarl.com/二叉树的递归遍历.html)中用递归的方式，实现了二叉树前中后序的遍历。
 
@@ -28,7 +29,7 @@
 
 如何标记呢，**就是要处理的节点放入栈之后，紧接着放入一个空指针作为标记。** 这种方法也可以叫做标记法。
 
-## 迭代法中序遍历
+### 迭代法中序遍历
 
 中序遍历代码如下：（详细注释）
 
@@ -71,7 +72,7 @@ public:
 
 此时我们再来看前序遍历代码。
 
-## 迭代法前序遍历
+### 迭代法前序遍历
 
 迭代法前序遍历代码如下： (**注意此时我们和中序遍历相比仅仅改变了两行代码的顺序**)
 
@@ -102,7 +103,7 @@ public:
 };
 ```
 
-## 迭代法后序遍历
+### 迭代法后序遍历
 
 后续遍历代码如下： (**注意此时我们和中序遍历相比仅仅改变了两行代码的顺序**)
 
@@ -143,15 +144,11 @@ public:
 
 所以大家根据自己的个人喜好，对于二叉树的前中后序遍历，选择一种自己容易理解的递归和迭代法。
 
+## 其他语言版本
 
-
-
-
-# 其他语言版本
-
-
-Java：
+### Java：
 迭代法前序遍历代码如下:
+
 ```java
 class Solution {
     public List<Integer> preorderTraversal(TreeNode root) {
@@ -235,7 +232,7 @@ class Solution {
 }
 ```
 
-Python：
+### Python：
 
 迭代法前序遍历：
 ```python
@@ -309,7 +306,8 @@ class Solution:
         return result
 ```
 
-Go：
+### Go：
+
 > 前序遍历统一迭代法
 
 ```GO
@@ -442,7 +440,7 @@ func postorderTraversal(root *TreeNode) []int {
 }
 ```
 
-javaScript:
+### JavaScript:
 
 > 前序遍历统一迭代法
 
@@ -522,7 +520,7 @@ var postorderTraversal = function(root, res = []) {
 
 ```
 
-TypeScript：
+### TypeScript：
 
 ```typescript
 // 前序遍历（迭代法）
@@ -591,7 +589,8 @@ function postorderTraversal(root: TreeNode | null): number[] {
     return res;
 };
 ```
-Scala:
+### Scala:
+
 ```scala
 // 前序遍历
 object Solution {
@@ -667,7 +666,7 @@ object Solution {
 }
 ```
 
-rust:
+### Rust:
 
 ```rust
 impl Solution{
@@ -747,3 +746,4 @@ impl Solution{
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
 </a>
+
diff --git a/problems/二叉树的迭代遍历.md b/problems/二叉树的迭代遍历.md
index 8b241465..69007995 100644
--- a/problems/二叉树的迭代遍历.md
+++ b/problems/二叉树的迭代遍历.md
@@ -4,16 +4,17 @@
 </a>
 <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
 
+> 听说还可以用非递归的方式
 
 # 二叉树的迭代遍历
 
-《代码随想录》算法视频公开课：
-* [写出二叉树的非递归遍历很难么？（前序和后序）](https://www.bilibili.com/video/BV15f4y1W7i2) 
-* [写出二叉树的非递归遍历很难么？（中序）)](https://www.bilibili.com/video/BV1Zf4y1a77g)
-相信结合视频在看本篇题解，更有助于大家对本题的理解。
+## 算法公开课
 
+[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：
 
-> 听说还可以用非递归的方式
+* **[写出二叉树的非递归遍历很难么？（前序和后序）](https://www.bilibili.com/video/BV15f4y1W7i2)** 
+* **[写出二叉树的非递归遍历很难么？（中序）)](https://www.bilibili.com/video/BV1Zf4y1a77g)**
+**相信结合视频在看本篇题解，更有助于大家对本题的理解。**
 
 看完本篇大家可以使用迭代法，再重新解决如下三道leetcode上的题目：
 
@@ -21,13 +22,15 @@
 * [94.二叉树的中序遍历](https://leetcode.cn/problems/binary-tree-inorder-traversal/)
 * [145.二叉树的后序遍历](https://leetcode.cn/problems/binary-tree-postorder-traversal/)
 
+## 思路
+
 为什么可以用迭代法（非递归的方式）来实现二叉树的前后中序遍历呢？
 
 我们在[栈与队列：匹配问题都是栈的强项](https://programmercarl.com/1047.删除字符串中的所有相邻重复项.html)中提到了，**递归的实现就是：每一次递归调用都会把函数的局部变量、参数值和返回地址等压入调用栈中**，然后递归返回的时候，从栈顶弹出上一次递归的各项参数，所以这就是递归为什么可以返回上一层位置的原因。
 
 此时大家应该知道我们用栈也可以是实现二叉树的前后中序遍历了。
 
-## 前序遍历（迭代法）
+### 前序遍历（迭代法）
 
 我们先看一下前序遍历。
 
@@ -69,7 +72,7 @@ public:
 
 但接下来，**再用迭代法写中序遍历的时候，会发现套路又不一样了，目前的前序遍历的逻辑无法直接应用到中序遍历上。**
 
-## 中序遍历（迭代法）
+### 中序遍历（迭代法）
 
 为了解释清楚，我说明一下 刚刚在迭代的过程中，其实我们有两个操作：
 
@@ -112,7 +115,7 @@ public:
 
 ```
 
-## 后序遍历（迭代法）
+### 后序遍历（迭代法）
 
 再来看后序遍历，先序遍历是中左右，后续遍历是左右中，那么我们只需要调整一下先序遍历的代码顺序，就变成中右左的遍历顺序，然后在反转result数组，输出的结果顺序就是左右中了，如下图：
 
@@ -142,7 +145,7 @@ public:
 
 ```
 
-# 总结
+## 总结
 
 此时我们用迭代法写出了二叉树的前后中序遍历，大家可以看出前序和中序是完全两种代码风格，并不像递归写法那样代码稍做调整，就可以实现前后中序。
 
@@ -155,11 +158,9 @@ public:
 当然可以，这种写法，还不是很好理解，我们将在下一篇文章里重点讲解，敬请期待！
 
 
+## 其他语言版本
 
-
-# 其他语言版本
-
-Java：
+### Java：
 
 ```java
 // 前序遍历顺序：中-左-右，入栈顺序：中-右-左
@@ -233,10 +234,7 @@ class Solution {
 }
 ```
 
-
-
-
-Python：
+### Python：
 
 ```python
 # 前序遍历-迭代-LC144_二叉树的前序遍历
@@ -281,7 +279,7 @@ class Solution:
                 # 取栈顶元素右结点
                 cur = cur.right	
         return result
- ```
+```
  ```python
 
 # 后序遍历-迭代-LC145_二叉树的后序遍历
@@ -303,10 +301,9 @@ class Solution:
                 stack.append(node.right)
         # 将最终的数组翻转
         return result[::-1]
-```
+ ```
 
-
-Go：
+### Go：
 
 > 迭代法前序遍历
 
@@ -400,7 +397,7 @@ func inorderTraversal(root *TreeNode) []int {
 }
 ```
 
-javaScript：
+### JavaScript：
 
 ```js
 
@@ -464,7 +461,7 @@ var postorderTraversal = function(root, res = []) {
 };
 ```
 
-TypeScript：
+### TypeScript：
 
 ```typescript
 // 前序遍历（迭代法）
@@ -519,7 +516,7 @@ function postorderTraversal(root: TreeNode | null): number[] {
 };
 ```
 
-Swift：
+### Swift：
 
 ```swift
 // 前序遍历迭代法
@@ -578,7 +575,8 @@ func inorderTraversal(_ root: TreeNode?) -> [Int] {
     return result
 }
 ```
-Scala:
+### Scala:
+
 ```scala
 // 前序遍历（迭代法）
 object Solution {
@@ -645,7 +643,7 @@ object Solution {
 }
 ```
 
-rust:
+### Rust:
 
 ```rust
 use std::cell::RefCell;
diff --git a/problems/二叉树的递归遍历.md b/problems/二叉树的递归遍历.md
index 92f342f0..730b18ac 100644
--- a/problems/二叉树的递归遍历.md
+++ b/problems/二叉树的递归遍历.md
@@ -4,15 +4,15 @@
 </a>
 <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
 
-
+> 一看就会，一写就废！
 
 # 二叉树的递归遍历
 
+## 算法公开课
 
-《代码随想录》算法视频公开课：[每次写递归都要靠直觉？ 这次带你学透二叉树的递归遍历！](https://www.bilibili.com/video/BV1Wh411S7xt)，相信结合视频在看本篇题解，更有助于大家对本题的理解。
+**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[每次写递归都要靠直觉？ 这次带你学透二叉树的递归遍历！](https://www.bilibili.com/video/BV1Wh411S7xt)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
 
-
-> 一看就会，一写就废！
+## 思路
 
 这次我们要好好谈一谈递归，为什么很多同学看递归算法都是“一看就会，一写就废”。
 
@@ -109,14 +109,10 @@ void traversal(TreeNode* cur, vector<int>& vec) {
 
 可能有同学感觉前后中序遍历的递归太简单了，要打迭代法（非递归），别急，我们明天打迭代法，打个通透！
 
+## 其他语言版本
 
+### Java：
 
-
-
-# 其他语言版本
-
-
-Java：
 ```Java
 // 前序遍历·递归·LC144_二叉树的前序遍历
 class Solution {
@@ -171,7 +167,8 @@ class Solution {
 }
 ```
 
-Python：
+### Python：
+
 ```python
 # 前序遍历-递归-LC144_二叉树的前序遍历
 # Definition for a binary tree node.
@@ -219,7 +216,7 @@ class Solution:
         return left + right + [root.val]
 ```
 
-Go：
+### Go：
 
 前序遍历:
 ```go
@@ -273,7 +270,7 @@ func postorderTraversal(root *TreeNode) (res []int) {
 }
 ```
 
-Javascript版本：
+### Javascript：
 
 前序遍历：
 ```Javascript
@@ -327,7 +324,7 @@ var postorderTraversal = function(root) {
 };
 ```
 
-TypeScript:
+### TypeScript:
 
 ```typescript
 // 前序遍历
@@ -370,7 +367,7 @@ function postorderTraversal(node: TreeNode | null): number[] {
 }
 ```
 
-C:
+### C:
 
 ```c
 //前序遍历：
@@ -422,8 +419,9 @@ int* postorderTraversal(struct TreeNode* root, int* returnSize){
 }
 ```
 
-Swift:
+### Swift:
 前序遍历：（144.二叉树的前序遍历）
+
 ```Swift
 func preorderTraversal(_ root: TreeNode?) -> [Int] {
     var res = [Int]()
@@ -473,7 +471,10 @@ func postorder(_ root: TreeNode?, res: inout [Int]) {
     res.append(root!.val)
 }
 ```
-Scala: 前序遍历：（144.二叉树的前序遍历）
+### Scala:
+
+ 前序遍历：（144.二叉树的前序遍历）
+
 ```scala
 object Solution {
   import scala.collection.mutable.ListBuffer
@@ -525,7 +526,7 @@ object Solution {
 }
 ```
 
-rust:
+### Rust:
 
 ```rust
 use std::cell::RefCell;