Update

Author: youngyangyang04

README.md

@@ -85,6 +85,7 @@
     * [二叉树：一入递归深似海，从此offer是路人](https://mp.weixin.qq.com/s/PwVIfxDlT3kRgMASWAMGhA)
     * [二叉树：听说递归能做的，栈也能做！](https://mp.weixin.qq.com/s/c_zCrGHIVlBjUH_hJtghCg)
     * [二叉树：前中后序迭代方式的写法就不能统一一下么？](https://mp.weixin.qq.com/s/WKg0Ty1_3SZkztpHubZPRg)
+    * [二叉树：层序遍历登场！](https://mp.weixin.qq.com/s/Gb3BjakIKGNpup2jYtTzog)
 
 （持续更新中....）
 
@@ -272,6 +273,8 @@
 |[0459.重复的子字符串](https://github.com/youngyangyang04/leetcode/blob/master/problems/0459.重复的子字符串.md) |字符创 |简单| **KMP**|
 |[0486.预测赢家](https://github.com/youngyangyang04/leetcode/blob/master/problems/0486.预测赢家.md) |动态规划 |中等| **递归** **记忆递归** **动态规划**|
 |[0491.递增子序列](https://github.com/youngyangyang04/leetcode/blob/master/problems/0491.递增子序列.md) |深度优先搜索 |中等|**深度优先搜索/回溯算法**|
+|[0501.二叉搜索树中的众数](https://github.com/youngyangyang04/leetcode/blob/master/problems/0501.二叉搜索树中的众数.md) |二叉树 |简单|**递归/中序遍历**|
+|[0515.在每个树行中找最大值](https://github.com/youngyangyang04/leetcode/blob/master/problems/0515.在每个树行中找最大值.md) |二叉树 |简单|**广度优先搜索/队列**|
 |[0538.把二叉搜索树转换为累加树](https://github.com/youngyangyang04/leetcode/blob/master/problems/0538.把二叉搜索树转换为累加树.md) |二叉树 |简单|**递归** **迭代**|
 |[0541.反转字符串II](https://github.com/youngyangyang04/leetcode/blob/master/problems/0541.反转字符串II.md) |字符串 |简单| **模拟**|
 |[0575.分糖果](https://github.com/youngyangyang04/leetcode/blob/master/problems/0575.分糖果.md) |哈希表 |简单|**哈希**|

pics/113.路径总和II.png

@@ -3,7 +3,7 @@ https://leetcode-cn.com/problems/binary-tree-level-order-traversal/
 
 > 我要打十个！
 
-看完这篇文章虽然不能打十个，但是可以迅速打五个！而且够快！
+看完这篇文章虽然不能打十个，但是可以迅速打六个！而且够快！
 
 
 # 102.二叉树的层序遍历 
@@ -35,7 +35,7 @@ https://leetcode-cn.com/problems/binary-tree-level-order-traversal/
 
 这样就实现了层序从左到右遍历二叉树。
 
-代码如下：**这份代码也可以作为二叉树层序遍历的模板，以后在打四个就靠它了**。
+代码如下：**这份代码也可以作为二叉树层序遍历的模板，以后再打五个就靠它了**。
 
 ## C++代码
 
@@ -64,7 +64,7 @@ public:
 };
 ```
 
-**此时我们就掌握了二叉树的层序遍历了，那么如下四道leetcode上的题目，只需要修改模板的一两行代码（不能再多了），便可打倒！**
+**此时我们就掌握了二叉树的层序遍历了，那么如下五道leetcode上的题目，只需要修改模板的一两行代码（不能再多了），便可打倒！**
 
 # 107.二叉树的层次遍历 II 
 
@@ -226,6 +226,37 @@ public:
 };
 ```
 
+# 515.在每个树行中找最大值 
+
+您需要在二叉树的每一行中找到最大的值。 
+
+<img src='../pics/515.在每个树行中找最大值.png' width=600> </img></div>
+
+## 思路
+
+层序遍历，取每一层的最大值
+
+## C++代码 
+
+```
+        queue<TreeNode*> que;
+        if (root != NULL) que.push(root);
+        vector<vector<int>> result;
+        while (!que.empty()) {
+            int size = que.size();
+            vector<int> vec;
+            // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
+            for (int i = 0; i < size; i++) {
+                TreeNode* node = que.front();
+                que.pop();
+                vec.push_back(node->val);
+                if (node->left) que.push(node->left);
+                if (node->right) que.push(node->right);
+            }
+            result.push_back(vec);
+        }
+        return result;
+```
 # 总结 
 
 二叉树的层序遍历，就是图论中的广度优先搜索在二叉树中的应用，需要借助队列来实现（此时是不是又发现队列的应用了）。
@@ -237,8 +268,9 @@ public:
 * 199.二叉树的右视图
 * 637.二叉树的层平均值
 * 589.N叉树的前序遍历
+* 515.在每个树行中找最大值
 
-虽然不能一口气打十个，打五个也还行。
+虽然不能一口气打十个，打六个也还行。
 
 如果非要打十个，还得找叶师傅！ 
 

pics/226.翻转二叉树.png

@@ -1,5 +1,7 @@
 ## 题目地址 
 
+# 112. 路径总和
+
 ## 思路 
 
 相信大家看到千篇一律的写法：

pics/226.翻转二叉树1.png

@@ -0,0 +1,72 @@
+
+## 链接 
+
+## 思路 
+
+这道题目与其说是递归，不如说是回溯问题，题目要找到所有的路径。
+
+这道题目相对于[112. 路径总和](https://leetcode-cn.com/problems/path-sum/) ，是要求出所有的路径和。
+
+
+**相信很多同学都疑惑递归的过程中究竟什么时候需要返回值，什么时候不需要返回值?**
+
+我在[112. 路径总和题解](https://leetcode-cn.com/problems/path-sum/solution/112-lu-jing-zong-he-di-gui-hui-su-die-dai-xiang-ji/)中给出了详细的解释。
+
+**如果需要搜索整颗二叉树，那么递归函数就不要返回值，如果要搜索其中一条符合条件的路径，递归函数就需要返回值，因为遇到符合条件的路径了就要及时返回。**
+
+而本题要遍历整个树，找到所有路径，**所以本题的递归函数不要返回值！**
+
+如图：
+
+<img src='../pics/107.二叉树的层次遍历II.png' width=600> </img></div>
+
+
+这道题目其实比[112. 路径总和](https://leetcode-cn.com/problems/path-sum/)简单一些，大家做完了本题，可以在做[112. 路径总和](https://leetcode-cn.com/problems/path-sum/)。
+
+为了尽可能的把回溯过程体现出来，我写出如下代码（**这个代码一定不是最简洁的，但是比较清晰的，过于简洁的代码不方便读者理解**）
+
+
+## C++代码
+
+```
+class Solution {
+private:
+    vector<vector<int>> result;
+    vector<int> path;
+    // 递归函数不需要返回值，因为我们要遍历整个树
+    void traversal(TreeNode* cur, int count) {
+        if (!cur->left && !cur->right && count == 0) { // 遇到了叶子节点切找到了和为sum的路径
+            result.push_back(path);
+            return;
+        }
+
+        if (!cur->left && !cur->right) return ; // 遇到叶子节点而没有找到合适的边，直接返回
+
+        if (cur->left) { // 左 （空节点不遍历）
+            path.push_back(cur->left->val);
+            count -= cur->left->val;
+            traversal(cur->left, count);    // 递归
+            count += cur->left->val;        // 回溯
+            path.pop_back();                // 回溯
+        }
+        if (cur->right) { // 右 （空节点不遍历）
+            path.push_back(cur->right->val);
+            count -= cur->right->val;
+            traversal(cur->right, count);   // 递归
+            count += cur->right->val;       // 回溯
+            path.pop_back();                // 回溯
+        }
+        return ;
+    }
+
+public:
+    vector<vector<int>> pathSum(TreeNode* root, int sum) {
+        result.clear();
+        path.clear();
+        if (root == NULL) return result;
+        path.push_back(root->val); // 把根节点放进路径
+        traversal(root, sum - root->val);
+        return result;
+    }
+};
+```

pics/515.在每个树行中找最大值.png

@@ -1,24 +1,59 @@
 ## 题目地址 
 https://leetcode-cn.com/problems/invert-binary-tree/
 
-## 思路 
+# 226.翻转二叉树
 
-### 递归法
-写递归算法的时候，要想一想是采用前中后序哪种遍历方式
-o
-如果对递归还不熟，可以看这里[彻底吃透二叉树的前中后序递归法和迭代法！！](https://leetcode-cn.com/problems/binary-tree-inorder-traversal/solution/che-di-chi-tou-er-cha-shu-de-qian-zhong-hou-xu-d-2/)
+翻转一棵二叉树。
 
-我们先看看递归算法，对于二叉树的递归方式有三种前中后序，先来看看前序遍历。
+<img src='../pics/226.翻转二叉树.png' width=600> </img></div>
 
-通过动画来看一下翻转的过程:
+这道题目背后有一个让程序员心酸的故事，听说 Homebrew的作者Max Howell，就是因为没在白板上写出翻转二叉树，最后被Google拒绝了。（真假不做判断，权当一个乐子哈） 
 
-<video src='../video/翻转二叉树.mp4' controls='controls' width='640' height='320' autoplay='autoplay'> Your browser does not support the video tag.</video></div>
+# 题外话 
 
-递归三部曲：
+这道题目是非常经典的题目，也是比较简单的题目（至少一看就会）。
+
+但正是因为这道题太简单，一看就会，一些同学都没有抓住起本质，稀里糊涂的就把这道题目过了。
+
+如果做过这道题的同学也建议认真看完，相信一定有所收获！
+
+# 思路 
+
+我们之前介绍的都是各种方式遍历二叉树，这次要翻转了，感觉还是有点懵逼。
+
+这得怎么翻转呢？ 
+
+如果要从整个树来看，翻转还真的挺复杂，整个树以中间分割线进行翻转，如图：
+
+<img src='../pics/226.翻转二叉树1.png' width=600> </img></div>
+
+可以发现想要翻转它，其实就把每一个节点的左右孩子交换一下就可以了。
+
+关键在于遍历顺序，前中后序应该选哪一种遍历顺序？ （一些同学这道题都过了，但是不知道自己用的是什么顺序）
+
+遍历的过程中去翻转每一个节点的左右孩子就可以达到整体翻转的效果。
+
+**注意只要把每一个节点的左右孩子翻转一下，就可以达到整体翻转的效果**
+
+**这道题目使用前序遍历和后序遍历都可以，唯独中序遍历不行，因为中序遍历会把某些节点的左右孩子翻转了两次！建议拿纸画一画，就理解了**
+
+那么层序遍历可以不可以呢？**依然可以的！只要把每一个节点的左右孩子翻转一下的遍历方式都是可以的！**
+
+## 递归法
+
+对于二叉树的递归法的前中后序遍历，已经在[二叉树：前中后序递归遍历](https://mp.weixin.qq.com/s/PwVIfxDlT3kRgMASWAMGhA)详细讲解了。
+
+我们下文以前序遍历为例，通过动画来看一下翻转的过程:
+
+<img src='../video/翻转二叉树.gif' width=600> </img></div>
+
+我们来看一下递归三部曲：
 
 1. 确定递归函数的参数和返回值
 
-参数就是要传入节点的指针，不需要其他参数了，返回值的话其实也不需要，但是题目中给出的要返回root节点的指针，可以直接使用题目定义好的函数，所以就返回一个指针。
+参数就是要传入节点的指针，不需要其他参数了，通常此时定下来主要参数，如果在写递归的逻辑中发现还需要其他参数的时候，随时补充。
+
+返回值的话其实也不需要，但是题目中给出的要返回root节点的指针，可以直接使用题目定义好的函数，所以就函数的返回类型为`TreeNode*`。
 
 ```
 TreeNode* invertTree(TreeNode* root)
@@ -34,7 +69,7 @@ if (root == NULL) return root;
 
 3. 确定单层递归的逻辑
 
-因为是先序遍历，所以先进行交换左右孩子节点，然后反转左子树，反转右子树。
+因为是先前序遍历，所以先进行交换左右孩子节点，然后反转左子树，反转右子树。
 
 ```
 swap(root->left, root->right);
@@ -49,34 +84,21 @@ class Solution {
 public:
     TreeNode* invertTree(TreeNode* root) {
         if (root == NULL) return root;
-        swap(root->left, root->right);
-        invertTree(root->left);
-        invertTree(root->right);
+        swap(root->left, root->right);  // 中
+        invertTree(root->left);         // 左
+        invertTree(root->right);        // 右
         return root;
     }
 };
 ```
 
-### 迭代法
+## 迭代法
 
-[leetcode-master](https://github.com/youngyangyang04/leetcode-master) 中给出了 前中后序迭代法统一的模板，使用前序遍历，只需要改动一行就可以了，代码在下面已经给出。
+### 深度优先遍历
 
-## C++代码
+[二叉树：听说递归能做的，栈也能做！](https://mp.weixin.qq.com/s/c_zCrGHIVlBjUH_hJtghCg)中给出了前中后序迭代方式的写法，所以本地可以很轻松的切出如下迭代法的代码：
 
-### 递归（前序遍历）
-```
-class Solution {
-public:
-    TreeNode* invertTree(TreeNode* root) {
-        if (root == NULL) return root;
-        swap(root->left, root->right);
-        invertTree(root->left);
-        invertTree(root->right);
-        return root;
-    }
-};
-```
-### 迭代法（前序遍历）
+C++代码迭代法（前序遍历）
 
 ```
 class Solution {
@@ -86,20 +108,22 @@ public:
         stack<TreeNode*> st;
         st.push(root);
         while(!st.empty()) {
-            TreeNode* node = st.top();
+            TreeNode* node = st.top();              // 中
             st.pop();
-            swap(node->left, node->right);
-            if(node->left) st.push(node->left);
-            if(node->right) st.push(node->right);
+            swap(node->left, node->right);          
+            if(node->right) st.push(node->right);   // 右
+            if(node->left) st.push(node->left);     // 左
         }
         return root;
     }
 };
 ```
+如果这个代码看不懂的话可以在回顾一下[二叉树：听说递归能做的，栈也能做！](https://mp.weixin.qq.com/s/c_zCrGHIVlBjUH_hJtghCg)。
+
 
-### 迭代法（前序遍历）（模板）
+我们在[二叉树：前中后序迭代方式的统一写法](https://mp.weixin.qq.com/s/WKg0Ty1_3SZkztpHubZPRg)中介绍了统一的写法，所以，本题也只需将文中的代码少做修改便可。
 
-模板地址：[leetcode-master](https://github.com/youngyangyang04/leetcode-master)
+C++代码如下迭代法（前序遍历）
 
 ```
 class Solution {
@@ -111,9 +135,9 @@ public:
             TreeNode* node = st.top();
             if (node != NULL) {
                 st.pop();
-                if (node->right) st.push(node->right);  // 添加右节点
-                if (node->left) st.push(node->left);    // 添加左节点
-                st.push(node);                          // 添加中节点
+                if (node->right) st.push(node->right);  // 右
+                if (node->left) st.push(node->left);    // 左
+                st.push(node);                          // 中
                 st.push(NULL);
             } else {
                 st.pop();
@@ -126,4 +150,45 @@ public:
     }
 };
 ```
+
+如果上面这个代码看不懂，回顾一下文章[二叉树：前中后序迭代方式的统一写法](https://mp.weixin.qq.com/s/WKg0Ty1_3SZkztpHubZPRg)。
+
+### 广度优先遍历
+
+也就是层序遍历，层数遍历也是可以翻转这棵树的，因为层序遍历也可以把每个节点的左右孩子都翻转一遍，代码如下：
+
+```
+class Solution {
+public:
+    TreeNode* invertTree(TreeNode* root) {
+        queue<TreeNode*> que;
+        if (root != NULL) que.push(root);
+        while (!que.empty()) {
+            int size = que.size();
+            for (int i = 0; i < size; i++) {
+                TreeNode* node = que.front();
+                que.pop();
+                swap(node->left, node->right); // 节点处理
+                if (node->left) que.push(node->left);
+                if (node->right) que.push(node->right);
+            }
+        }
+        return root;
+    }
+};
+```
+如果对以上代码不理解，或者不清楚二叉树的层序遍历，可以看这篇[二叉树：层序遍历登场！](https://mp.weixin.qq.com/s/Gb3BjakIKGNpup2jYtTzog)
+
+# 总结 
+
+针对二叉树的问题，解题之前一定要想清楚究竟是前中后序遍历，还是层序遍历。
+
+**二叉树解题的大忌就是自己稀里糊涂的过了（因为这道题相对简单），但是也不知道自己是怎么遍历的。**
+
+这也是造成了二叉树的题目“一看就会，一写就废”的原因。
+
+**针对翻转二叉树，我给出了一种递归，三种迭代（两种模拟深度优先遍历，一种层序遍历）的写法，都是之前我们讲过的写法，融汇贯通一下而已。**
+
+大家一定也有自己的解法，但一定要成方法论，这样才能通用，才能举一反三！
+
 > 更多算法干货文章持续更新，可以微信搜索「代码随想录」第一时间围观，关注后，回复「Java」「C++」 「python」「简历模板」「数据结构与算法」等等，就可以获得我多年整理的学习资料。

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

@@ -0,0 +1,6 @@
+
+## 题目地址 
+https://leetcode-cn.com/problems/find-largest-value-in-each-tree-row/
+## 思路 
+详见：
+    * [0102.二叉树的层序遍历](https://github.com/youngyangyang04/leetcode/blob/master/problems/0102.二叉树的层序遍历.md)