Update

Author: youngyangyang04

README.md

@@ -82,6 +82,8 @@
 
 * 二叉树 
     * [关于二叉树，你该了解这些！](https://mp.weixin.qq.com/s/_ymfWYvTNd2GvWvC5HOE4A)
+    * [二叉树：一入递归深似海，从此offer是路人](https://mp.weixin.qq.com/s/PwVIfxDlT3kRgMASWAMGhA)
+    * [二叉树：听说递归能做的，栈也能做！](https://mp.weixin.qq.com/s/c_zCrGHIVlBjUH_hJtghCg)
 
 （持续更新中....）
 
@@ -214,6 +216,7 @@
 |[0107.二叉树的层次遍历II](https://github.com/youngyangyang04/leetcode/blob/master/problems/0107.二叉树的层次遍历II.md) |树 |简单|**广度优先搜索/队列/BFS**|
 |[0110.平衡二叉树](https://github.com/youngyangyang04/leetcode/blob/master/problems/0110.平衡二叉树.md) |树 |简单|**递归**|
 |[0111.二叉树的最小深度](https://github.com/youngyangyang04/leetcode/blob/master/problems/0111.二叉树的最小深度.md) |树 |简单|**递归** **队列/BFS**|
+|[0112.路径总和](https://github.com/youngyangyang04/leetcode/blob/master/problems/0112.路径总和.md) |树 |简单|**深度优先搜索/递归** **回溯** **栈**|
 |[0131.分割回文串](https://github.com/youngyangyang04/leetcode/blob/master/problems/0131.分割回文串.md) |回溯 |中等|**回溯**|
 |[0142.环形链表II](https://github.com/youngyangyang04/leetcode/blob/master/problems/0142.环形链表II.md) |链表 |中等|**快慢指针/双指针**|
 |[0144.二叉树的前序遍历](https://github.com/youngyangyang04/leetcode/blob/master/problems/0144.二叉树的前序遍历.md) |树 |中等|**递归** **迭代/栈**|

pics/112.路径总和.png

@@ -1,27 +1,49 @@
 ## 题目地址 
 
 ## 思路 
-// 遍历单条边，还是遍历整个树，取最优数值！！
-// 对啊，用sum来减法啊，免得多定义一个变量
 
-## C++ 
+相信大家看到千篇一律的写法：
+```
+class Solution {
+public:
+    bool hasPathSum(TreeNode* root, int sum) {
+        if (root == NULL) return false;
+        if (!root->left && !root->right && sum == root->val) {
+            return true;
+        }
+        return hasPathSum(root->left, sum - root->val) || hasPathSum(root->right, sum - root->val);
+    }
+};
+```
+**这种写法简短是简短，但其实对于读者理解不是很友好，没有很好的体现出递归的顺序已经背后的回溯。**
+
+**相信很多同学都疑惑递归的过程中究竟什么时候需要返回值，什么时候不需要返回值？**
 
-贼粗糙的写法 
+**如果需要搜索整颗二叉树，那么递归函数就不要返回值，如果要搜索其中一条符合条件的路径，递归函数就需要返回值，因为遇到符合条件的路径了就要及时返回。**
 
-深度优先遍历
+而本题就要要搜索一条路径，使其上所有节点值相加等于目标和，所以递归需要返回值！ 
+
+如图所示：
+
+<img src='../pics/112.路径总和.png' width=600> </img></div>
+
+图中可以看出，遍历的路线，并不要遍历整棵树，所以递归函数需要返回值，可以用bool类型表示。
+
+那么使用深度优先遍历的方式（本题前中后序都可以，无所谓）来遍历二叉树，如下代码我尽量将每一步清晰的表现出来，C++代码如下：
 
 ```
 class Solution {
 private:
     bool traversal(TreeNode* cur, int count) {
         if (!cur->left && !cur->right && count == 0) return true; // 遇到叶子节点，并且计数为0
-        if (!cur->left && !cur->right) return false; // 遇到叶子节点直接返回
+        
+        if (!cur->left && !cur->right) return false; // 遇到叶子节点而没有找到合适的边，直接返回
 
-        if (cur->left) { // 左
+        if (cur->left) { // 左 （空节点不遍历）
             // 遇到叶子节点返回true，则直接返回true
             if (traversal(cur->left, count - cur->left->val)) return true;
         }
-        if (cur->right) { // 右
+        if (cur->right) { // 右 （空节点不遍历）
             // 遇到叶子节点返回true，则直接返回true
             if (traversal(cur->right, count - cur->right->val)) return true;
         }
@@ -36,7 +58,8 @@ public:
 };
 ```
 
-其实本题一定是有回溯的，没有回溯，如果后撤重新找另一条路径呢，但是貌似以上代码中，**大家貌似没有感受到回溯，那是因为回溯在代码里隐藏起来了。**
+
+那么其实本题一定是有回溯的，没有回溯，如何后撤重新找另一条路径呢，但是貌似以上代码中，**大家貌似没有感受到回溯，那是因为回溯在代码里隐藏起来了。**
 
 隐藏在`traversal(cur->left, count - cur->left->val)`这里， 因为把`count - cur->left->val` 直接作为参数传进去，函数结束，count自然恢复到原先的数值了。
 
@@ -79,3 +102,45 @@ public:
     }
 };
 ```
+
+如果使用栈模拟递归的话，那么如果做回溯呢？ 
+
+此时栈里一个元素不仅要记录该节点指针，还要记录从头结点到该节点的路径数值总和。 
+
+C++就我们用pair结构来存放这个栈里的元素。
+
+定义为：`pair<TreeNode*, int>` pair<节点指针，路径数值>
+
+这个为栈里的一个元素。
+
+如下代码是使用栈模拟的前序遍历，如下：（详细注释）
+
+```
+class Solution {
+
+public:
+    bool hasPathSum(TreeNode* root, int sum) {
+        if (root == NULL) return false;
+        // 此时栈里要放的是pair<节点指针，路径数值>
+        stack<pair<TreeNode*, int>> st;
+        st.push(pair<TreeNode*, int>(root, root->val));
+        while (!st.empty()) {
+            pair<TreeNode*, int> node = st.top();
+            st.pop();
+            // 如果该节点是叶子节点了，同时该节点的路径数值等于sum，那么就返回true
+            if (!node.first->left && !node.first->right && sum == node.second) return true;
+
+            // 右节点，压进去一个节点的时候，将该节点的路径数值也记录下来
+            if (node.first->right) {
+                st.push(pair<TreeNode*, int>(node.first->right, node.second + node.first->right->val));
+            }
+
+            // 左节点，压进去一个节点的时候，将该节点的路径数值也记录下来
+            if (node.first->left) {
+                st.push(pair<TreeNode*, int>(node.first->left, node.second + node.first->left->val));
+            }
+        }
+        return false;
+    }
+};
+```

pics/501.二叉搜索树中的众数.png

@@ -0,0 +1,179 @@
+## 题目地址 
+
+https://leetcode-cn.com/problems/find-mode-in-binary-search-tree/solution/
+
+# 思路 
+
+
+## 暴力统计
+
+这看到这道题目，最直观的方法一定是把这个树都遍历了，用map统计频率，用vector排个序，最后出去前面高频的元素。
+
+其实这是可以的，也是有效的，面试中时间紧张，可能快速的把这个方法实现出来，后面在考虑满满优化。
+
+
+至于用前中后序那种遍历也不重要，因为就是要全遍历一遍，怎么个遍历法都行，层序遍历都没毛病！
+
+这种方法C++代码如下：
+
+
+```
+class Solution {
+private:
+
+void searchBST(TreeNode* cur, unordered_map<int, int>& map) { // 前序遍历
+    if (cur == NULL) return ;
+    map[cur->val]++; // 统计元素频率
+    searchBST(cur->left, map);
+    searchBST(cur->right, map);
+    return ;
+}
+bool static cmp (const pair<int, int>& a, const pair<int, int>& b) {
+    return a.second > b.second;
+}
+public:
+    vector<int> findMode(TreeNode* root) {
+        unordered_map<int, int> map;
+        vector<int> result;
+        if (root == NULL) return result;
+        searchBST(root, map);
+        vector<pair<int, int>> vec(map.begin(), map.end());
+        sort(vec.begin(), vec.end(), cmp); // 给频率排个序
+        result.push_back(vec[0].first);
+        for (int i = 1; i < vec.size(); i++) {
+            if (vec[i].second == vec[0].second) result.push_back(vec[i].first);
+            else break;
+        }
+        return result;
+    }
+};
+```
+
+**这种方法的缺点是没有利用上二叉搜索树这一特性**，如果用这种方法，这道题就可以是普通的二叉树就行了，反正都要全撸一遍统计频率。
+
+## 中序遍历
+
+既然是搜索树，它就是有序的，那么如何有序呢？ 
+
+**搜索树在中序遍历的过程中，就是有序序列，所以此时的问题相当于 给出如果给出一个有序数组，求最大频率的元素集合。** 
+
+**所以我们要采用中序遍历！**
+
+如图：
+
+<img src='../pics/501.二叉搜索树中的众数1.png' width=600> </img></div>
+
+中序遍历代码如下：
+
+```
+    void searchBST(TreeNode* cur) {
+        if (cur == NULL) return ;
+        searchBST(cur->left);       // 左
+        （处理节点）                // 中
+        searchBST(cur->right);      // 右
+        return ;
+    }
+```
+
+遍历有序数组的元素出现频率，从头遍历，那么一定是相邻两个元素作比较，要是数组的话，好搞，在树上怎么搞呢？ 
+
+需要弄一个指针指向前一个节点，这样每次cur（当前节点）才能和pre（前一个节点）作比较。
+
+而且初始化的时候pre = NULL，这样当pre为NULL时候，我们就知道这是比较的第一个元素，然后再给pre赋值即pre = cur;
+
+代码如下：
+
+```
+        if (pre == NULL) { // 第一个节点
+            count = 1;
+        } else if (pre->val == cur->val) { // 与前一个节点数值相同
+            count++;
+        } else { // 与前一个节点数值不同
+            count = 1;
+        }
+        pre = cur; // 更新上一个节点
+```
+
+此时又有问题了，因为要求最大频率的元素集合，直观想的想法是要先遍历一遍找出频率最大的次数maxCount，然后在重新遍历一遍再把出现频率为maxCount的元素放进集合。
+
+
+那么如何只遍历一遍呢？
+
+如果 频率count 等于 maxCount，当然要把这个元素加入到结果集中（以下代码为result数组），代码如下：
+
+```
+        if (count == maxCount) { // 如果和最大值相同，放进result中
+            result.push_back(cur->val);
+        }
+```
+
+当时感觉这里有问题，result怎么能轻易就把元素放进去了呢，万一，这个maxCount此时还不是真正最大值呢。
+
+所以下面要做如下操作：
+
+频率count 大于 maxCount的时候，不仅要更新maxCount，而且要清空结果集（以下代码为result数组），因为结果集之前的元素都失效了。
+
+```
+        if (count > maxCount) { // 如果计数大于最大值
+            maxCount = count;
+            result.clear();     // 很关键的一步，不要忘记清空result，之前result里的元素都失效了
+            result.push_back(cur->val);
+        }
+```
+
+关键代码都讲完了，完整代码如下：
+
+
+```
+class Solution {
+private:
+    int count;
+    int maxCount;
+    TreeNode* pre;
+    vector<int> result;
+    void searchBST(TreeNode* cur) {
+        if (cur == NULL) return ;
+
+        searchBST(cur->left);       // 左
+                                    // 中
+        if (pre == NULL) { // 第一个节点
+            count = 1;
+        } else if (pre->val == cur->val) { // 与前一个节点数值相同
+            count++;
+        } else { // 与前一个节点数值不同
+            count = 1;
+        }
+        pre = cur; // 更新上一个节点
+
+        if (count == maxCount) { // 如果和最大值相同，放进result中
+            result.push_back(cur->val);
+        }
+
+        if (count > maxCount) { // 如果计数大于最大值
+            maxCount = count;
+            result.clear();     // 很关键的一步，不要忘记清空result，之前result里的元素都失效了
+            result.push_back(cur->val);
+        }
+
+        searchBST(cur->right);      // 右
+        return ;
+    }
+
+public:
+    vector<int> findMode(TreeNode* root) {
+        int count = 0; // 记录元素出现次数
+        int maxCount = 0;
+        TreeNode* pre = NULL; // 记录前一个节点
+        result.clear();
+
+        searchBST(root);
+        return result;
+    }
+};
+```
+
+此时的运行效率：
+
+<img src='../pics/501.二叉搜索树中的众数.png' width=600> </img></div>
+
+**需要强调的是 leetcode上的耗时统计是非常不准确的，看个大概就行，一样的代码耗时可以差百分之50以上**，所以leetcode的耗时统计别太当回事，知道理论上的效率优劣就行了。