Update

README.md

@@ -123,7 +123,8 @@
     * [二叉树：搜索树中的删除操作](https://mp.weixin.qq.com/s/-p-Txvch1FFk3ygKLjPAKw)
     * [二叉树：修剪一棵搜索树](https://mp.weixin.qq.com/s/QzmGfYUMUWGkbRj7-ozHoQ)
     * [二叉树：构造一棵搜索树](https://mp.weixin.qq.com/s/sy3ygnouaZVJs8lhFgl9mw)
-
+    * [二叉树：搜索树转成累加树](https://mp.weixin.qq.com/s/hZtJh4T5lIGBarY-lZJf6Q)
+    * [二叉树：总结篇！（需要掌握的二叉树技能都在这里了）](https://mp.weixin.qq.com/s/-ZJn3jJVdF683ap90yIj4Q)
  
 
 （持续更新中....）

problems/0053.最大子序和.md

@@ -1,6 +1,3 @@
-> 笔者在BAT从事技术研发多年，利用工作之余重刷leetcode，更多原创技术文章欢迎关注「代码随想录」，校招社招求职内推欢迎通过公众号「代码随想录」联系我，度厂很缺人！
-
-> 笔者在BAT从事技术研发多年，利用工作之余重刷leetcode，希望结合自己多年的实践经验，把算法讲的更清楚，更多原创文章欢迎关注公众号「代码随想录」。
 
 ## 题目地址 
 https://leetcode-cn.com/problems/maximum-subarray/

problems/0077.组合.md

@@ -1,4 +1,8 @@
+
 # 第77题. 组合
+
+题目链接：https://leetcode-cn.com/problems/combinations/ 
+
 给定两个整数 n 和 k，返回 1 ... n 中所有可能的 k 个数的组合。
 示例:
 
@@ -13,6 +17,7 @@
   [1,4],
 ]
 
+
 # 思路 
 
 这是回溯法的经典题目。
@@ -33,65 +38,122 @@
 那么就三层for循环，代码如下：
 
 ```
-    for (int i = 1; i <= n; i++) {
+for (int i = 1; i <= n; i++) {
-        for (int j = i + 1; j <= n; j++) {
+    for (int j = i + 1; j <= n; j++) {
-            for (int u = j + 1; u <=n; n++) {
+        for (int u = j + 1; u <=n; n++) {
 
-            }
         }
     }
-```
-**如果n为 100，k为50呢，那就50层for循环，是不是开始窒息。**
-
-那么回溯法就能解决这个问题了。
-
-回溯是用来做选择的，递归用来节点层叠嵌套，**每一次的递归是层叠嵌套的关系，可以用于解决多层嵌套循环的问题。**
-
-其实子集和组合问题都可以抽象为一个树形结构，如下：
-
-
-<img src='../pics/77.组合.png' width=600> </img></div>
-
-可以看一下这个棵树，一开始集合是 1，2，3，4， 从左向右去数，取过的数，不在重复取。
-
-第一取1，集合变为2，3，4 ，因为k为2，我们只需要去一个数就可以了，分别取，2，3，4， 得到集合[1,2] [1,3] [1,4]，以此类推。
-
-**其实这就转化成从集合中选取子集的问题，可选择的范围随着选择的进行而限缩，于是做剪枝，调整可选择的范围**
-
-如何在这个树上遍历，然后收集到我们要的结果集呢，用的就是回溯搜索法，**可以发现，每次搜索到了叶子节点，我们就找到了一个结果。**
-
-分析完过程，我们来看一下 回溯算法的模板框架如下：
-```
-backtracking() {
-    if (终止条件) {
-        存放结果;
-    }
-
-    for (选择：选择列表（可以想成树中节点孩子的数量）) {
-        递归，处理节点;
-        backtracking();
-        回溯，撤销处理结果
-    }
 }
 ```
 
-分析模板：
+**如果n为100，k为50呢，那就50层for循环，是不是开始窒息**。
 
-什么是达到了终止条件，树中就可以看出，搜到了叶子节点了，就找到了一个符合题目要求的答案，就把这个答案存放起来。
+那么回溯法就能解决这个问题了。
 
-看一下这个for循环，这个for循环是做什么的，for 就是处理树中节点各个孩子的情况， 一个节点有多少个孩子，这个for循环就执行多少次。
+回溯是用来做选择，递归用来做节点层叠嵌套（可以理解是随便开K的for循环），**每一次的递归相当于嵌套一个for循环，可以用于解决多层嵌套循环的问题了**。
 
-最后就要看这个递归的过程了，注意这个backtracking就是自己调用自己，实现递归。
+**回溯问题都可以抽象为一棵树形结构！用树形结构来理解回溯就容易多了**。
 
-一些同学对递归操作本来就不熟练，递归上面又加上一个for循环，可能就更迷糊了， 我来给大家捋顺一下。
+那么我们把组合问题抽象为如下树形结构：
 
-这个backtracking 其实就是向树的叶子节点方向遍历， for循环可以理解是横向遍历，backtracking 就是纵向遍历，这样就把这棵树全遍历完了。
+<img src='../pics/77.组合.png' width=600> </img></div>
 
-那么backtracking就是一直往深处遍历，总会遇到叶子节点，遇到了叶子节点，就要返回，那么backtracking的下面部分就是回溯的操作了，撤销本次处理的结果。
+可以看出这个棵树，一开始集合是 1，2，3，4， 从左向右取数，取过的数，不在重复取。
 
-分析完模板，本题代码如下：
+第一次取1，集合变为2，3，4 ，因为k为2，我们只需要再取一个数就可以了，分别取，2，3，4， 得到集合[1,2] [1,3] [1,4]，以此类推。
+
+**回溯的问题都可以抽象为一个树形结构，在求解组合问题的过程中，n相当于树的宽度，k相当于树的深度**。
+
+**每次从集合中选组元素，可选择的范围随着选择的进行而限缩，调整可选择的范围**
+
+如何在这个树上遍历，然后收集到我们要的结果集呢？
+
+用的就是回溯搜索法，**可以发现，每次搜索到了叶子节点，我们就找到了一个结果**。
+
+
+**这份模板，大家可以要记住了，后面做回溯搜索的题目，都离不开这个模板**。 
+
+## 求组合
+
+掌握了模板之后，我们再来看一下这道求组合的题目。
+
+* 回溯函数返回值以及参数 
+
+在这里要定义两个全局变量，一个用来存放符合条件单一结果，一个用来存放符合条件结果的集合。
+
+代码如下：
+
+```
+vector<vector<int>> result; // 存放符合条件结果的集合
+vector<int> path; // 用来存放符合条件结果
+```
+
+其实不定义这两个全局遍历也是可以的，把这两个变量放进回溯函数的参数里，但为了函数里参数太多影响可读性，所以我定义全局变量。
+
+首先两个参数，集合n里面取k的数，是两个int型的变量。
+
+然后还需要一个参数，也为int型变量startIndex，这个参数用来记录本层递归的中，集合从哪里开始遍历（集合就是[1,...,n] ）。
+
+为什么要有这个startIndex呢？ 
+
+从下图中红线部分可以看出，在集合[1,2,3,4]取1之后，下一层递归，就要在[2,3,4]中取数了，那么下一层递归如何知道从[2,3,4]中取数呢，靠的就是startIndex。
+
+<img src='../pics/77.组合2.png' width=600> </img></div>
+
+所以需要startIndex来记录下一层递归，搜索的起始位置。 
+
+那么整体代码如下：
+
+```
+vector<vector<int>> result; // 存放符合条件结果的集合
+vector<int> path; // 用来存放符合条件单一结果
+void backtracking(int n, int k, int startIndex) 
+```
+
+* 回溯函数终止条件 
+
+什么时候到达所谓的叶子节点了呢？
+
+就是path这个数组的大小如果达到k，说明我们找到了一个集合大小为k的组合了，在图中path存的就是根节点到叶子节点的路径。
+
+如图红色部分：
+
+<img src='../pics/77.组合3.png' width=600> </img></div>
+
+此时用result二维数组，把path保存起来，并终止本层递归。
+
+所以终止条件代码如下：
+
+```
+if (path.size() == k) {
+    result.push_back(path);
+    return;
+}
+```
+
+
+* 回溯搜索的遍历过程 
+
+在如下如中，我们知道for循环用来横向遍历，递归的过程是纵向遍历。
+<img src='../pics/77.组合1.png' width=600> </img></div>
+
+如此我们才遍历完图中的这棵树。
+
+那么for循环每次就是从startIndex开始遍历，然后用path保存每次遍历到的节点。 
+
+代码如下：
+
+```
+for (int i = startIndex; i <= n; i++) {
+    path.push_back(i); // 处理节点 
+    backtracking(n, k, i + 1); // 注意下一层搜索要从i+1开始
+    path.pop_back(); // 回溯，撤销处理的节点
+}
+```
+
+关键地方都讲完了，组合问题C++完整代码如下：
 
-# C++ 代码
 
 ```
 class Solution {
@@ -103,7 +165,6 @@ private:
             result.push_back(path);
             return;
         }
-        // 这个for循环有讲究，组合的时候 要用startIndex，排列的时候就要从0开始
         for (int i = startIndex; i <= n; i++) {
             path.push_back(i); // 处理节点 
             backtracking(n, k, i + 1);
@@ -111,8 +172,9 @@ private:
         }
     }
 public:
-
     vector<vector<int>> combine(int n, int k) {
+        result.clear();  // 可以不写
+        path.clear(); // 可以不写
         backtracking(n, k, 1);
         return result;
     }
@@ -145,7 +207,7 @@ for (int i = startIndex; i <= n; i++)
 for (int i = startIndex; i <= n - (k - path.size()) + 1; i++)
 ```
 
-整体代码如下：
+优化后整体代码如下：
 
 ```
 class Solution {
@@ -157,7 +219,6 @@ private:
             result.push_back(path);
             return;
         }
-        // 这个for循环有讲究，组合的时候 要用startIndex，排列的时候就要从0开始
         for (int i = startIndex; i <= n - (k - path.size()) + 1; i++) {
             path.push_back(i); // 处理节点 
             backtracking(n, k, i + 1);
@@ -174,6 +235,3 @@ public:
 ```
 
 
-
-# 观后感 
-我来写一下观后感： 很厉害，转化成从集合中选取子集的问题，可选择的范围随着选择的进行而限缩，于是做剪枝，调整可选择的范围。 每一次的递归是层叠嵌套的关系，可以用于解决多层嵌套循环的问题。 每一层递归中，尽量节省循环次数，这样在后续的递归调用中，节省下来的循环会被以至少指数等级放大。

problems/0104.二叉树的最大深度.md

@@ -174,12 +174,13 @@ public:
         int depth = 0; 
         while (!que.empty()) {
             int size = que.size();
+            vector<int> vec;
             depth++; // 记录深度
             for (int i = 0; i < size; i++) {
                 Node* node = que.front();
                 que.pop();
-                for (int i = 0; i < node->children.size(); i++) {
+                for (int j = 0; j < node->children.size(); j++) {
-                    if (node->children[i]) que.push(node->children[i]);
+                    if (node->children[j]) que.push(node->children[j]);
                 }
             }
         }

problems/0559.N叉树的最大深度.md

@@ -31,12 +31,12 @@ public:
         while (!que.empty()) {
             int size = que.size();
             vector<int> vec;
-            depth++;
+            depth++; // 记录深度
             for (int i = 0; i < size; i++) {
                 Node* node = que.front();
                 que.pop();
-                for (int i = 0; i < node->children.size(); i++) {
+                for (int j = 0; j < node->children.size(); j++) {
-                    if (node->children[i]) que.push(node->children[i]);
+                    if (node->children[j]) que.push(node->children[j]);
                 }
             }
         }

problems/二叉树总结.md

@@ -0,0 +1,147 @@
+> 二叉树大总结！
+
+不知不觉二叉树已经和我们度过了**三十三天**，代码随想录里已经发了**三十三篇二叉树的文章**，详细讲解了**30+二叉树经典题目**，一直坚持下来的录友们一定会二叉树有深刻理解了。
+
+在每一道二叉树的题目中，我都使用了**递归三部曲**来分析题目，相信大家以后看到二叉树，看到递归，都会想：返回值、参数是什么？终止条件是什么？单层逻辑是什么？
+
+而且**几乎每一道题目我都给出对应的迭代法**，可以用来进一步提高自己。
+
+下面Carl把分析过的题目分门别类，可以帮助新录友循序渐进学习二叉树，也方便老录友面试前快速复习，看到一个标题，就回想一下对应的解题思路，这样很快就可以系统性的复习一遍二叉树了。
+
+公众号的发文顺序，就是循序渐进的，所以如下分类基本就是按照文章发文顺序来的，我再做一个系统性的分类。
+
+# 二叉树的理论基础 
+
+* [关于二叉树，你该了解这些！](https://mp.weixin.qq.com/s/_ymfWYvTNd2GvWvC5HOE4A)：二叉树的种类、存储方式、遍历方式、定义方式
+
+# 二叉树的遍历方式 
+
+*  深度优先遍历 
+    * [二叉树：前中后序递归法](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)：通过队列模拟
+
+
+# 求二叉树的属性
+
+* [二叉树：是否对称](https://mp.weixin.qq.com/s/Kgf0gjvlDlNDfKIH2b1Oxg)
+    * 递归：后序，比较的是根节点的左子树与右子树是不是相互翻转
+    * 迭代：使用队列/栈将两个节点顺序放入容器中进行比较
+* [二叉树：求最大深度](https://mp.weixin.qq.com/s/guKwV-gSNbA1CcbvkMtHBg) 
+    * 递归：后序，求根节点最大高度就是最大深度，通过递归函数的返回值做计算树的高度
+    * 迭代：层序遍历
+* [二叉树：求最小深度](https://mp.weixin.qq.com/s/BH8-gPC3_QlqICDg7rGSGA) 
+    * 递归：后序，求根节点最小高度就是最小深度，注意最小深度的定义
+    * 迭代：层序遍历 
+* [二叉树：求有多少个节点](https://mp.weixin.qq.com/s/2_eAjzw-D0va9y4RJgSmXw) 
+    * 递归：后序，通过递归函数的返回值计算节点数量
+    * 迭代：层序遍历
+* [二叉树：是否平衡](https://mp.weixin.qq.com/s/isUS-0HDYknmC0Rr4R8mww)
+    * 递归：后序，注意后序求高度和前序求深度，递归过程判断高度差
+    * 迭代：效率很低，不推荐
+* [二叉树：找所有路径](https://mp.weixin.qq.com/s/Osw4LQD2xVUnCJ-9jrYxJA) 
+    * 递归：前序，方便让父节点指向子节点，涉及回溯处理根节点到叶子的所有路径
+    * 迭代：一个栈模拟递归，一个栈来存放对应的遍历路径
+* [二叉树：递归中如何隐藏着回溯](https://mp.weixin.qq.com/s/ivLkHzWdhjQQD1rQWe6zWA) 
+    * 详解[二叉树：找所有路径](https://mp.weixin.qq.com/s/Osw4LQD2xVUnCJ-9jrYxJA)中递归如何隐藏着回溯
+* [二叉树：求左叶子之和](https://mp.weixin.qq.com/s/gBAgmmFielojU5Wx3wqFTA)
+    * 递归：后序，必须三层约束条件，才能判断是否是左叶子。
+    * 迭代：直接模拟后序遍历 
+* [二叉树：求左下角的值](https://mp.weixin.qq.com/s/MH2gbLvzQ91jHPKqiub0Nw)
+    * 递归：顺序无所谓，优先左孩子搜索，同时找深度最大的叶子节点。
+    * 迭代：层序遍历找最后一行最左边 
+* [二叉树：求路径总和](https://mp.weixin.qq.com/s/6TWAVjxQ34kVqROWgcRFOg)
+    * 递归：顺序无所谓，递归函数返回值为bool类型是为了搜索一条边，没有返回值是搜索整棵树。 
+    * 迭代：栈里元素不仅要记录节点指针，还要记录从头结点到该节点的路径数值总和
+
+
+
+# 二叉树的修改与构造
+
+* [翻转二叉树](https://mp.weixin.qq.com/s/6gY1MiXrnm-khAAJiIb5Bg)
+    * 递归：前序，交换左右孩子 
+    * 迭代：直接模拟前序遍历
+* [构造二叉树](https://mp.weixin.qq.com/s/7r66ap2s-shvVvlZxo59xg)
+    * 递归：前序，重点在于找分割点，分左右区间构造 
+    * 迭代：比较复杂，意义不大
+* [构造最大的二叉树](https://mp.weixin.qq.com/s/1iWJV6Aov23A7xCF4nV88w)
+    * 递归：前序，分割点为数组最大值，分左右区间构造 
+    * 迭代：比较复杂，意义不大
+* [合并两个二叉树](https://mp.weixin.qq.com/s/3f5fbjOFaOX_4MXzZ97LsQ)
+    * 递归：前序，同时操作两个树的节点，注意合并的规则 
+    * 迭代：使用队列，类似层序遍历
+
+# 求二叉搜索树的属性
+
+* [二叉搜索树中的搜索](https://mp.weixin.qq.com/s/vsKrWRlETxCVsiRr8v_hHg)
+    * 递归：二叉搜索树的递归是有方向的 
+    * 迭代：因为有方向，所以迭代法很简单
+* [是不是二叉搜索树](https://mp.weixin.qq.com/s/8odY9iUX5eSi0eRFSXFD4Q)
+    * 递归：中序，相当于变成了判断一个序列是不是递增的 
+    * 迭代：模拟中序，逻辑相同
+* [求二叉搜索树的最小绝对差](https://mp.weixin.qq.com/s/Hwzml6698uP3qQCC1ctUQQ)
+    * 递归：中序，双指针操作  
+    * 迭代：模拟中序，逻辑相同
+* [求二叉搜索树的众数](https://mp.weixin.qq.com/s/KSAr6OVQIMC-uZ8MEAnGHg)
+    * 递归：中序，清空结果集的技巧，遍历一遍便可求众数集合
+    * 迭代：模拟中序，逻辑相同
+* [二叉搜索树转成累加树](https://mp.weixin.qq.com/s/hZtJh4T5lIGBarY-lZJf6Q)
+    * 递归：中序，双指针操作累加 
+    * 迭代：模拟中序，逻辑相同
+
+# 二叉树公共祖先问题
+
+* [二叉树的公共祖先问题](https://mp.weixin.qq.com/s/n6Rk3nc_X3TSkhXHrVmBTQ)
+    * 递归：后序，回溯，找到左子树出现目标值，右子树节点目标值的节点。
+    * 迭代：不适合模拟回溯
+* [二叉搜索树的公共祖先问题](https://mp.weixin.qq.com/s/Ja9dVw2QhBcg_vV-1fkiCg)
+    * 递归：顺序无所谓，如果节点的数值在目标区间就是最近公共祖先 
+    * 迭代：按序遍历
+
+# 二叉搜索树的修改与构造 
+
+* [二叉搜索树中的插入操作](https://mp.weixin.qq.com/s/lwKkLQcfbCNX2W-5SOeZEA)
+    * 递归：顺序无所谓，通过递归函数返回值添加节点 
+    * 迭代：按序遍历，需要记录插入父节点，这样才能做插入操作
+* [二叉搜索树中的删除操作](https://mp.weixin.qq.com/s/-p-Txvch1FFk3ygKLjPAKw)
+    * 递归：前序，想清楚删除非叶子节点的情况 
+    * 迭代：有序遍历，较复杂
+* [修剪二叉搜索树](https://mp.weixin.qq.com/s/QzmGfYUMUWGkbRj7-ozHoQ)
+    * 递归：前序，通过递归函数返回值删除节点 
+    * 迭代：有序遍历，较复杂
+* [构造二叉搜索树](https://mp.weixin.qq.com/s/sy3ygnouaZVJs8lhFgl9mw)
+    * 递归：前序，数组中间节点分割 
+    * 迭代：较复杂，通过三个队列来模拟
+
+# 阶段总结 
+
+大家以上题目都做过了，也一定要看如下阶段小结。
+
+**每周小结都会对大家的疑问做统一解答，并且对每周的内容进行拓展和补充，所以一定要看，将细碎知识点一网打尽！**
+
+* [本周小结！（二叉树系列一）](https://mp.weixin.qq.com/s/JWmTeC7aKbBfGx4TY6uwuQ)
+* [本周小结！（二叉树系列二）](https://mp.weixin.qq.com/s/QMBUTYnoaNfsVHlUADEzKg)
+* [本周小结！（二叉树系列三）](https://mp.weixin.qq.com/s/JLLpx3a_8jurXcz6ovgxtg) 
+* [本周小结！（二叉树系列四）](https://mp.weixin.qq.com/s/CbdtOTP0N-HIP7DR203tSg)
+
+# 最后总结 
+
+**在二叉树题目选择什么遍历顺序是不少同学头疼的事情，我们做了这么多二叉树的题目了，Carl给大家大体分分类**。
+
+* 涉及到二叉树的构造，无论普通二叉树还是二叉搜索树一定前序，都是先构造中节点。
+
+* 求普通二叉树的属性，一般是后序，一般要通过递归函数的返回值做计算。
+
+* 求二叉搜索树的属性，一定是中序了，要不白瞎了有序性了。
+
+注意在普通二叉树的属性中，我用的是一般为后序，例如单纯求深度就用前序， [二叉树：找所有路径](https://mp.weixin.qq.com/s/Osw4LQD2xVUnCJ-9jrYxJA)也用了前序，这是为了方便让父节点指向子节点。
+
+所以求普通二叉树的属性还是要具体问题具体分析。
+
+**最后，二叉树系列就这么完美结束了，估计这应该是最长的系列了，感谢大家33天的坚持与陪伴，接下来我们又要开始新的系列了「回溯算法」！**
+
+
+**录友们打卡的时候也说一说自己的感想吧！哈哈**
+

problems/回溯算法理论基础.md

@@ -0,0 +1,118 @@
+
+> 
+
+# 什么是回溯法 
+回溯法也可以叫做回溯搜索法，它是一种搜索的方式。 
+
+在二叉树系列中，我们已经不止一次，提到了回溯，例如[二叉树：以为使用了递归，其实还隐藏着回溯](https://mp.weixin.qq.com/s/ivLkHzWdhjQQD1rQWe6zWA)。
+
+回溯是递归的副产品，只要有递归就会有回溯。
+
+回溯法的性能如何呢，这里要很大家说清楚了，**虽然回溯法很难，很不好理解，但是回溯法并不是什么高效的算法**。
+
+# 回溯法的效率
+
+**因为回溯的本质是穷举，穷举所有可能，然后选出我们想要的答案**，如果想让回溯法高效一些，可以加一些剪枝的操作，但也改不了回溯法就是穷举的本质。
+
+那么既然回溯法并不高效为什么还要用它呢？ 
+
+因为没得选，一些问题只能暴力搜，没有更优的算法了。
+
+# 回溯法解决的问题 
+
+
+
+回溯算法，相信
+
+**回溯的问题都可以抽象为一个树形结构，在求解组合问题的过程中，n相当于树的宽度，k相当于树的深度**。
+
+# 题外话 
+
+一些同学可能分不清什么是组合，什么是排列？
+
+组合是不强调元素顺序的，排列是强调元素顺序的。
+
+例如：{1, 2} 和 {2, 1} 在组合上，就是一个集合，因为不强调顺序，而要是排列的话，{1, 2} 和 {2, 1} 就是两个集合了。
+
+## 回溯算法模板 
+
+这里将给出Carl总结的回溯算法模板，那么先来讲一讲回溯算法的模板伪代码。
+
+既然回溯是递归的副产品，那么必然要有递归。
+
+**所以以下讲解中，回溯函数也就是递归函数，指的都是一个函数**。
+
+在讲[二叉树的递归](https://mp.weixin.qq.com/s/PwVIfxDlT3kRgMASWAMGhA)中我们说了递归三部曲，这里我再给大家列出回溯三部曲。
+
+* 回溯函数模板返回值以及参数 
+
+回溯函数伪代码如下：
+
+```
+backtracking(参数) 
+```
+
+在回溯算法中，我的习惯函数起名字为backtracking，回溯中递归返回值一般为void。 
+
+在来看一下参数，因为回溯算法需要的参数，可不像二叉树递归的时候那么容易一次性确定下来，所以一般是先写逻辑，需要什么参数，就填什么参数。
+
+但后面的回溯题目的讲解中，为了方便理解，我在一开始就帮大家把参数确定下来。
+
+* 回溯函数终止条件 
+
+回溯函数终止条件伪代码如下：
+```
+if (终止条件) {
+    存放结果;
+}
+```
+
+既然是树形结构，那么我们在讲解[二叉树的递归](https://mp.weixin.qq.com/s/PwVIfxDlT3kRgMASWAMGhA)的时候，就知道遍历树形结构一定要有终止条件。
+
+所以回溯也有要终止条件。
+
+什么时候达到了终止条件，树中就可以看出，搜到了叶子节点了，就找到了一个符合题目要求的答案，就把这个答案存放起来。
+
+
+* 回溯搜索的遍历过程 
+
+回溯函数遍历过程伪代码如下：
+```
+for (选择：选择列表（可以想成树中每个节点孩子的数量）) {
+    递归，处理节点;
+    backtracking(路径，选择列表);
+    回溯，撤销处理结果
+}
+```
+
+看一下这个for循环，这个for循环是做什么呢？
+
+for 就是处理树中每一个节点的各个孩子的情况， 一个节点有多少个孩子，这个for循环就执行多少次。
+
+注意这个backtracking就是自己调用自己，实现递归。
+
+**一些同学对递归操作本来就不熟练，递归上面又加上一个for循环，可能就更迷糊了**， 我再给大家捋顺一下。
+
+这个backtracking（递归函数）是从根节点向树的叶子节点方向遍历，**for循环可以理解是横向遍历，backtracking（递归）就是纵向遍历**，这样就把这棵树全遍历完了，如图所示：
+
+<img src='../pics/77.组合1.png' width=600> </img></div>
+
+backtracking一直往深处遍历，总会遇到叶子节点，遇到了叶子节点就要返回，那么backtracking的下面部分就是回溯的操作了，撤销本次处理的结果。
+
+分析完过程，回溯算法模板框架如下：
+
+```
+backtracking(参数) {
+    if (终止条件) {
+        存放结果;
+    }
+
+    for (选择：选择列表（可以想成树中每个节点孩子的数量）) {
+        递归，处理节点;
+        backtracking(路径，选择列表);
+        回溯，撤销处理结果
+    }
+}
+
+```
+

problems/链表总结篇.md

@@ -1,4 +1,7 @@
 
+> 链表理论基础
+
+
 * [关于链表，你该了解这些！](https://mp.weixin.qq.com/s/ntlZbEdKgnFQKZkSUAOSpQ)
     * [链表：听说用虚拟头节点会方便很多？](https://mp.weixin.qq.com/s/slM1CH5Ew9XzK93YOQYSjA)
     * [链表：一道题目考察了常见的五个操作！](https://mp.weixin.qq.com/s/Cf95Lc6brKL4g2j8YyF3Mg)