添加更多文章动画

10f6268b · misterbooo · c1aef7e0 · 10f6268b · 10f6268b · 10f6268b
Commit 10f6268b authored May 02, 2019 by misterbooo
--- a/LeetCode 第 349 号问题：两个数组的交集.md
+++ b/LeetCode 第 349 号问题：两个数组的交集.md
+# LeetCode 第 349 号问题：两个数组的交集
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+题目来源于 LeetCode 上第 349 号问题：两个数组的交集。题目难度为 Easy，目前通过率为 62.3% 。
+### 题目描述
+给定两个数组，编写一个函数来计算它们的交集。
+**示例 1:**
+```
+输入: nums1 = [1,2,2,1], nums2 = [2,2]
+输出: [2]
+```
+**示例 2:**
+```
+输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
+输出: [9,4]
+```
+**说明:**
+- 输出结果中的每个元素一定是唯一的。
+- 我们可以不考虑输出结果的顺序。
+### 题目解析
+容器类 [set](https://zh.cppreference.com/w/cpp/container/set) 的使用。
+- 遍历 num1，通过 set 容器 record 存储 num1 的元素
+- 遍历 num2 ，在 record 中查找是否有相同的元素，如果有，用 set 容器 resultSet 进行存储
+- 将 resultSet 转换为 vector 类型
+### 动画描述
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20190502123122.gif)
+### 代码实现
+```
+class Solution {
+public:
+    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
+        set<int> record;
+        for(int i = 0; i < nums1.size(); i ++){
+            record.insert(nums1[i]);
+        }
+        set<int> resultSet;
+        for(int i = 0; i < nums2.size();i++){
+            if(record.find(nums2[i]) != record.end()){
+                resultSet.insert(nums2[i]);
+            }
+        }
+        vector<int> resultVector;
+        for(set<int>::iterator iter=resultSet.begin(); iter != resultSet.end();iter++){
+            resultVector.push_back(*iter);
+        }
+        return resultVector;
+    }
+};
+```
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/fz0rq.png)
\ No newline at end of file
--- a/LeetCode 第 350 号问题：两个数组的交集 II.md
+++ b/LeetCode 第 350 号问题：两个数组的交集 II.md
+# LeetCode 第 350 号问题：两个数组的交集 II
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+题目来源于 LeetCode 上第 350 号问题：两个数组的交集 II。题目难度为 Easy，目前通过率为 41.8% 。
+### 题目描述
+给定两个数组，编写一个函数来计算它们的交集。
+**示例 1:**
+```
+输入: nums1 = [1,2,2,1], nums2 = [2,2]
+输出: [2,2]
+```
+**示例 2:**
+```
+输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
+输出: [4,9]
+```
+**说明：**
+- 输出结果中每个元素出现的次数，应与元素在两个数组中出现的次数一致。
+- 我们可以不考虑输出结果的顺序。
+**进阶:**
+- 如果给定的数组已经排好序呢？你将如何优化你的算法？
+- 如果 *nums1* 的大小比 *nums2* 小很多，哪种方法更优？
+- 如果 *nums2* 的元素存储在磁盘上，磁盘内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？
+### 题目解析
+容器类 [map](https://zh.cppreference.com/w/cpp/container/map) 的使用。
+- 遍历 num1，通过map容器 record 存储 num1 的元素与频率
+- 遍历 num2 ，在 record 中查找是否有相同的元素（该元素的存储频率大于0），如果有，用map容器resultVector 进行存储，同时该元素的频率减一
+### 动画描述
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181027160512.gif)
+### 代码实现
+```
+// 350. Intersection of Two Arrays II
+// https://leetcode.com/problems/intersection-of-two-arrays-ii/description/
+// 时间复杂度: O(nlogn)
+// 空间复杂度: O(n)
+class Solution {
+public:
+    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
+        map<int, int> record;
+        for(int i = 0 ; i < nums1.size() ; i ++){
+             record[nums1[i]] += 1;
+        }
+        vector<int> resultVector;
+        for(int i = 0 ; i < nums2.size() ; i ++){
+            if(record[nums2[i]] > 0){
+                resultVector.push_back(nums2[i]);
+                record[nums2[i]] --;
+            }
+        }
+        return resultVector;
+    }
+};
+```
+#### 执行结果
+![img](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181029083150.png)
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/fz0rq.png)
\ No newline at end of file
--- a/LeetCode 第 445 号问题：两数相加 II.md
+++ b/LeetCode 第 445 号问题：两数相加 II.md
+# LeetCode 第 445 号问题：两数相加 II
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+题目来源于 LeetCode 上第 445 号问题：两数相加 II。题目难度为 Medium，目前通过率为 48.8% 。
+### 题目描述
+给定两个**非空**链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储单个数字。将这两数相加会返回一个新的链表。
+你可以假设除了数字 0 之外，这两个数字都不会以零开头。
+**进阶:**
+如果输入链表不能修改该如何处理？换句话说，你不能对列表中的节点进行翻转。
+**示例:**
+```
+输入: (7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4)
+输出: 7 -> 8 -> 0 -> 7
+```
+### 题目解析
+由于计算时要保证最右边的数对齐，那么很自然的想到先用**栈**存放链表中的每个值，然后依次计算。由于相加时可能产生进位，所以使用一个flag表示是否有进位。   
+提示：若栈中元素相加结束之后仍有进位，则需要新加入一个头结点。
+### 动画描述
+![](https://diycode.b0.upaiyun.com/photo/2019/3b0e95a2e5c00ab1071a7232ca329e62.gif)
+### 代码实现
+```python
+class Solution:
+    def addTwoNumbers(self, l1, l2):
+        # 分别入栈
+        stack1 = []
+        stack2 = []
+        while l1:
+            stack1.append(l1.val)
+            l1 = l1.next
+        while l2:
+            stack2.append(l2.val)
+            l2 = l2.next
+        flag = 0
+        head = None
+        while stack1 or stack2 or flag != 0:
+            if stack1:
+                flag += stack1.pop()
+            if stack2:
+                flag += stack2.pop()
+            node = ListNode(flag % 10)
+            node.next = head
+            head = node
+            flag = flag // 10
+        return head
+```
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/fz0rq.png)
\ No newline at end of file
--- a/LeetCode 第 447 号问题：回旋镖的数量.md
+++ b/LeetCode 第 447 号问题：回旋镖的数量.md
+# LeetCode 第 447 号问题：回旋镖的数量
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+题目来源于 LeetCode 上第 447 号问题：回旋镖的数量。题目难度为 Easy，目前通过率为 45.8% 。
+### 题目描述
+给定平面上 *n* 对不同的点，“回旋镖” 是由点表示的元组 `(i, j, k)` ，其中 `i` 和 `j` 之间的距离和 `i` 和 `k` 之间的距离相等（**需要考虑元组的顺序**）。
+找到所有回旋镖的数量。你可以假设 *n* 最大为 **500**，所有点的坐标在闭区间 **[-10000, 10000]** 中。
+**示例:**
+```
+输入:
+[[0,0],[1,0],[2,0]]
+输出:
+2
+解释:
+两个回旋镖为 [[1,0],[0,0],[2,0]] 和 [[1,0],[2,0],[0,0]]
+```
+### 题目解析
+n 最大为 500，可以使用时间复杂度为 O(n^2)的算法。
+- 遍历所有的点，让每个点作为一个锚点
+- 然后再遍历其他的点，统计和锚点距离相等的点有多少个
+- 然后分别带入 n(n-1) 计算结果并累加到res中
+##### Tips：
+###### Tip1
+- 如果有一个点 a，还有两个点 b 和 c ，如果 ab 和 ac 之间的距离相等，那么就有两种排列方法 abc 和 acb；
+- 如果有三个点 b，c，d都分别和a之间的距离相等，那么有六种排列方法，abc, acb, acd, adc, abd, adb；
+- 如果有 n 个点和点 a 距离相等，那么排列方式为 n(n-1)。
+###### Tip2
+- 计算距离时不进行开根运算, 以保证精度；
+- 只有当n大于等于2时，res值才会真正增加，因为当n=1时，增加量为`1*(1-1)=0`。
+### 动画描述
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181030112917.gif)
+### 代码实现
+```
+// 447. Number of Boomerangs
+// https://leetcode.com/problems/number-of-boomerangs/description/
+// 时间复杂度: O(n^2)
+// 空间复杂度: O(n)
+class Solution {
+public:
+    int numberOfBoomerangs(vector<pair<int, int>>& points) {
+        int res = 0;
+        for( int i = 0 ; i < points.size() ; i ++ ){
+            // record中存储 点i 到所有其他点的距离出现的频次
+            unordered_map<int, int> record;
+            for(int j = 0 ; j < points.size() ; j ++){
+                if(j != i){
+                    // 计算距离时不进行开根运算, 以保证精度
+                    record[dis(points[i], points[j])] += 1;
+                }
+            }
+            for(unordered_map<int, int>::iterator iter = record.begin() ; iter != record.end() ; iter ++){
+                res += (iter->second) * (iter->second - 1);
+            }
+        }
+        return res;
+    }
+private:
+    int dis(const pair<int,int> &pa, const pair<int,int> &pb){
+        return (pa.first - pb.first) * (pa.first - pb.first) +
+               (pa.second - pb.second) * (pa.second - pb.second);
+    }
+};
+```
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/fz0rq.png)
\ No newline at end of file
--- a/LeetCode 第 454 号问题：四数相加 II.md
+++ b/LeetCode 第 454 号问题：四数相加 II.md
+# LeetCode 第 454 号问题：四数相加 II
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+题目来源于 LeetCode 上第 454 号问题：四数相加 II。题目难度为 Medium，目前通过率为 50.8% 。
+### 题目描述
+给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 `(i, j, k, l)` ，使得 `A[i] + B[j] + C[k] + D[l] = 0`。
+为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500 。所有整数的范围在 -228 到 228 - 1 之间，最终结果不会超过 231 - 1 。
+**例如:**
+```
+输入:
+A = [ 1, 2]
+B = [-2,-1]
+C = [-1, 2]
+D = [ 0, 2]
+输出:
+2
+解释:
+两个元组如下:
+1. (0, 0, 0, 1) -> A[0] + B[0] + C[0] + D[1] = 1 + (-2) + (-1) + 2 = 0
+2. (1, 1, 0, 0) -> A[1] + B[1] + C[0] + D[0] = 2 + (-1) + (-1) + 0 = 0
+```
+### 题目解析
+与[Two Sum](https://xiaozhuanlan.com/topic/7923618450)类似，需要用哈希表来解决问题。
+- 把 A 和 B 的两两之和都求出来，在哈希表中建立两数之和与其出现次数之间的映射
+- 遍历 C 和 D 中任意两个数之和，只要看哈希表存不存在这两数之和的相反数就行了
+### 动画描述
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181029154232.gif)
+### 代码实现
+```
+// 454. 4Sum II
+// https://leetcode.com/problems/4sum-ii/description/
+// 时间复杂度: O(n^2)
+// 空间复杂度: O(n^2)
+class Solution {
+public:
+    int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D) {
+        unordered_map<int,int> hashtable;
+        for(int i = 0 ; i < A.size() ; i ++){
+            for(int j = 0 ; j < B.size() ; j ++){
+                 hashtable[A[i]+B[j]] += 1;
+            }
+        }
+        int res = 0;
+        for(int i = 0 ; i < C.size() ; i ++){
+            for(int j = 0 ; j < D.size() ; j ++){
+                if(hashtable.find(-C[i]-D[j]) != hashtable.end()){
+                    res += hashtable[-C[i]-D[j]];
+                }
+            }
+        }
+        return res;
+    }
+};
+```
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/fz0rq.png)
\ No newline at end of file
--- a/LeetCode 第 642 号问题：设计一个搜索自动完成系统.md
+++ b/LeetCode 第 642 号问题：设计一个搜索自动完成系统.md
+# LeetCode 第 642 号问题：设计一个搜索自动完成系统
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+题目来源于 LeetCode 上第 642 号问题：设计一个搜索自动完成系统。题目难度为 Hard，目前通过率为 37.8% 。
+### 题目描述
+为搜索引擎设计一个搜索自动完成系统。用户可以输入一个句子(至少一个单词，并以一个特殊的字符'#'结尾)。对于除'#'之外的每个字符，您需要返回与已输入的句子部分前缀相同的前3个历史热门句子。具体规则如下:
+一个句子的热度定义为用户输入完全相同句子的次数。
+返回的前3个热门句子应该按照热门程度排序(第一个是最热的)。如果几个句子的热度相同，则需要使用ascii代码顺序(先显示较小的一个)。
+如果少于3个热门句子，那么就尽可能多地返回。
+当输入是一个特殊字符时，它意味着句子结束，在这种情况下，您需要返回一个空列表。
+您的工作是实现以下功能:
+构造函数:
+AutocompleteSystem(String[] sentence, int[] times):这是构造函数。输入是历史数据。句子是由之前输入的句子组成的字符串数组。Times是输入一个句子的相应次数。您的系统应该记录这些历史数据。
+现在，用户想要输入一个新句子。下面的函数将提供用户类型的下一个字符:
+List<String> input(char c):输入c是用户输入的下一个字符。字符只能是小写字母(“a”到“z”)、空格(“”)或特殊字符(“#”)。另外，前面输入的句子应该记录在系统中。输出将是前3个历史热门句子，它们的前缀与已经输入的句子部分相同。
+例子:
+操作:AutocompleteSystem(["i love you"， "island"，"ironman"， "i love leetcode"]， [5,3,2,2])
+系统已经追踪到以下句子及其对应的时间:
+"i love you" : 5 times 
+"island" : 3 times 
+"ironman" : 2 times 
+"i love leetcode" : 2 times 
+现在，用户开始另一个搜索:
+操作:输入(“i”)
+输出:["i love you"， "island"，"i love leetcode"]
+解释:
+有四个句子有前缀“i”。其中，《ironman》和《i love leetcode》有着相同的热度。既然“ ” ASCII码为32，“r”ASCII码为114，那么“i love leetcode”应该在“ironman”前面。此外，我们只需要输出前3个热门句子，所以“ironman”将被忽略。
+操作:输入(' ')
+输出:[“i love you”，“i love leetcode”]
+解释:
+只有两个句子有前缀“i”。
+操作:输入(' a ')
+输出:[]
+解释:
+没有以“i a”为前缀的句子。
+操作:输入(“#”)
+输出:[]
+解释:
+用户完成输入后，在系统中将句子“i a”保存为历史句。下面的输入将被计算为新的搜索。
+注意:
+输入的句子总是以字母开头，以“#”结尾，两个单词之间只有一个空格。
+要搜索的完整句子不会超过100个。包括历史数据在内的每句话的长度不会超过100句。
+在编写测试用例时，即使是字符输入，也请使用双引号而不是单引号。
+请记住重置在AutocompleteSystem类中声明的类变量，因为静态/类变量是跨多个测试用例持久化的。详情请点击这里。
+### 题目解析
+设计一个搜索自动补全系统，它需要包含如下两个方法：
+#### 构造方法：
+AutocompleteSystem(String[] sentences, int[] times): 输入句子sentences，及其出现次数times
+#### 输入方法：
+List<String> input(char c): 输入字符c可以是26个小写英文字母，也可以是空格，以'#'结尾。返回输入字符前缀对应频率最高的至多3个句子，频率相等时按字典序排列。
+### 思路解析：
+核心点：Trie（字典树）
+利用字典树记录所有出现过的句子集合，利用字典保存每个句子出现的次数。
+#### 解题思路
+题目的要求是补全的句子是按之前出现的频率排列的，高频率的出现在最上面，如果频率相同，就按字母顺序来显示。
+频率 这种要求很容易想到 堆、优先队列、树、Map等知识点，这里涉及到 字典 与 树，那肯定使用 字典树 能解决。
+所以首先构造 Trie 的 trieNode 结构以及 insert 方法，构造完 trieNode 类后，再构造一个树的根节点。
+由于每次都要输入一个字符，我们可以用一个私有的 Node：curNode 来追踪当前的节点。
+curNode 初始化为 root ，在每次输入完一个句子时，即输入的字符为‘#’时，我们需要将其置为root。
+同时还需要一个 string 类型 stn 来表示当前的搜索的句子。
+每输入一个字符，首先检查是不是结尾标识“#”，如果是的话，将当前句子加入trie树，重置相关变量，返回空数组。
+* 如不是，检查当前 TrieNode 对应的 child 是否含有 c 的对应节点。如果没有，将 curNode 置为 NULL 并且返回空数组。
+* 若存在，将curNode 更新为c对应的节点，并且对curNode进行dfs。
+dfs 时，我们首先检查当前是不是一个完整的句子，如果是，将句子与其次数同时加入 priority_queue 中，然后对其 child 中可能存在的子节点进行 dfs 。
+进行完 dfs 后，只需要取出前三个，需要注意的是，可能可选择的结果不满3个，所以要在 while 中多加入检测 q 为空的条件语句。
+最后要将 q 中的所有元素都弹出。
+### 动画描述
+动画是使用 AE 制作，体积比较大，有 32 M，无法使用GIF播放，因此采取视频播放形式，手机党慎点：）  
+感谢 **Jun Chen** 大佬提供动画技术支持，笔芯。
+https://v.qq.com/x/page/m08267nr4fv.html
+### 代码实现
+#### C++
+```
+class TrieNode{
+  public:
+    string str;
+    int cnt;
+    unordered_map<char, TrieNode*> child;
+    TrieNode(): str(""), cnt(0){};
+};
+struct cmp{
+    bool operator() (const pair<string, int> &p1, const pair<string, int> &p2){
+        return p1.second < p2.second || (p1.second == p2.second && p1.first > p2.first);
+    }
+};
+class AutocompleteSystem {
+public:
+    AutocompleteSystem(vector<string> sentences, vector<int> times) {
+        root = new TrieNode();
+        for(int i = 0; i < sentences.size(); i++){
+            insert(sentences[i], times[i]);
+        }
+        curNode = root;
+        stn = "";
+    }
+    vector<string> input(char c) {
+        if(c == '#'){
+            insert(stn, 1);
+            stn.clear();
+            curNode = root;
+            return {};
+        }
+        stn.push_back(c);
+        if(curNode && curNode->child.count(c)){
+            curNode = curNode->child[c];
+        }else{
+            curNode = NULL;
+            return {};
+        }
+        dfs(curNode);
+        vector<string> ret;
+        int n = 3;
+        while(n > 0 && !q.empty()){
+            ret.push_back(q.top().first);
+            q.pop();
+            n--;
+        }
+        while(!q.empty()) q.pop();
+        return ret;
+    }
+    void dfs(TrieNode* n){
+        if(n->str != ""){
+            q.push({n->str, n->cnt});
+        }
+        for(auto p : n->child){
+            dfs(p.second);
+        }
+    }
+    void insert(string s, int cnt){
+        TrieNode* cur = root;
+        for(auto c : s){
+            if(cur->child.count(c) == 0){
+                cur->child[c] = new TrieNode();
+            }
+            cur = cur->child[c];
+        }
+        cur->str = s;
+        cur->cnt += cnt;
+    }
+private:
+    TrieNode *root, *curNode;
+    string stn;
+    priority_queue<pair<string,int>, vector<pair<string, int>>, cmp > q;
+};
+```
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/fz0rq.png)
\ No newline at end of file
--- a/LeetCode 第 690 号问题：员工的重要性.md
+++ b/LeetCode 第 690 号问题：员工的重要性.md
+# LeetCode 第 690 号问题：员工的重要性
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+题目来源于 LeetCode 第 690 号问题：员工的重要性。
+### 题目描述
+给定一个保存员工信息的数据结构，它包含了员工**唯一的id**，**重要度** 和 **直系下属的id**。
+比如，员工 1 是员工 2 的领导，员工 2 是员工 3 的领导。他们相应的重要度为 15, 10, 5 。那么员工 1 的数据结构是[1, 15, [2]]，员工 2 的数据结构是[2, 10, [3]]，员工3的数据结构是[3, 5, []]。注意虽然员工 3 也是员工 1 的一个下属，但是由于**并不是直系**下属，因此没有体现在员工1的数据结构中。
+现在输入一个公司的所有员工信息，以及单个员工 id，返回这个员工和他所有下属的重要度之和。
+**示例 1:**
+```
+输入: [[1, 5, [2, 3]], [2, 3, []], [3, 3, []]], 1
+输出: 11
+解释:
+员工 1 自身的重要度是 5，他有两个直系下属 2 和 3 ，而且 2 和 3 的重要度均为 3 。因此员工 1 的总重要度是 5 + 3 + 3 = 11。
+```
+**注意:**
+1. 一个员工最多有一个**直系**领导，但是可以有多个**直系**下属
+2. 员工数量不超过 2000。
+### 
+### 题目解析
+利用哈希表来存储员工的信息，找到指定 id 的员工后，采用广度优先遍历算法来遍历编号为 id 的员工及其下属员工。
+### 动画描述
+待补充
+### 代码实现
+```
+public int getImportance(List<Employee> employees, int id) {
+        Employee emp = null;
+        //重要度
+		int sum = 0;   
+        //存储员工信息
+		HashMap<Integer,Employee> map=new HashMap<Integer,Employee>();  /
+	    for(Employee e:employees) {
+	    	map.put(e.id, e);
+	    }
+	    //使用广度优先遍历员工
+	    ArrayDeque<Employee> queue=new ArrayDeque<Employee>();
+	    queue.addLast(map.get(id));
+	    while(!queue.isEmpty()) {
+	    	emp=queue.removeFirst();
+	    	sum+=emp.importance;
+	    	for(int i:emp.subordinates) {
+	    		queue.addLast(map.get(i));
+	    	}
+	    }
+		return sum;
+    }
+```
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/fz0rq.png)
\ No newline at end of file
--- a/LeetCode 第 75 号问题：颜色分类.md
+++ b/LeetCode 第 75 号问题：颜色分类.md
+# LeetCode 第 75 号问题：颜色分类
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+题目来源于 LeetCode 上第 75 号问题：颜色分类。题目难度为 Medium，目前通过率为 51.8% 。
+### 题目描述
+给定一个包含红色、白色和蓝色，一共 *n* 个元素的数组，**原地**对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。
+此题中，我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。
+**注意:**
+不能使用代码库中的排序函数来解决这道题。
+**示例:**
+```
+输入: [2,0,2,1,1,0]
+输出: [0,0,1,1,2,2]
+```
+**进阶：**
+- 一个直观的解决方案是使用计数排序的两趟扫描算法。
+  首先，迭代计算出0、1 和 2 元素的个数，然后按照0、1、2的排序，重写当前数组。
+- 你能想出一个仅使用常数空间的一趟扫描算法吗？
+### 题目解析
+结合三路快排 partition 思路的应用。
+设定两个索引，一个从左往右滑动`zero`，一个从右往左滑动`two`。
+* 遍历`nums`，当`nums[i]`的值为1时，`i++`；
+* 当`nums[i]`的值为2时，`two`的值先减1，而后交换`nums[i]`与`nums[two]`，此时在观察`nums[i]`的值；
+* 当`nums[i]`的值为0时，`zero++`，而后交换`nums[i]`与`nums[zero]`，`i++`;当 `i = two`时，结束循环。
+### 动画描述
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20190502094455.gif)
+### 代码实现
+```
+// 三路快速排序的思想
+// 对整个数组只遍历了一遍
+// 时间复杂度: O(n)
+// 空间复杂度: O(1)
+class Solution {
+public:
+    void sortColors(vector<int> &nums) {
+        int zero = -1;          // [0...zero] == 0
+        int two = nums.size();  // [two...n-1] == 2
+        for(int i = 0 ; i < two ; ){
+            if(nums[i] == 1){
+                 i ++;
+            }else if (nums[i] == 2){
+                 two--;
+                 swap( nums[i] , nums[two]);
+            }else{ // nums[i] == 0
+                 zero++;
+                 swap(nums[zero] , nums[i]);
+                 i++;
+            }
+        }
+    }
+};
+```
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/fz0rq.png)
\ No newline at end of file
--- a/LeetCode 第 86 号问题：分割链表.md
+++ b/LeetCode 第 86 号问题：分割链表.md
+# LeetCode 第 86 号问题：分割链表
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+题目来源于 LeetCode 上第 86 号问题：分割链表。题目难度为 Easy，目前通过率为 47.8% 。
+### 题目描述
+给定一个链表和一个特定值 *x*，对链表进行分隔，使得所有小于 *x* 的节点都在大于或等于 *x* 的节点之前。
+你应当保留两个分区中每个节点的初始相对位置。
+**示例:**
+```
+输入: head = 1->4->3->2->5->2, x = 3
+输出: 1->2->2->4->3->5
+```
+### 题目解析
+这道题要求我们划分链表，把所有小于给定值的节点都移到前面，大于该值的节点顺序不变，相当于一个局部排序的问题。
+- 设定两个虚拟节点，`dummyHead1 `用来保存小于于该值的链表，`dummyHead2 `来保存大于等于该值的链表
+- 遍历整个原始链表，将小于该值的放于`dummyHead1 `中，其余的放置在`dummyHead2 `中
+- 遍历结束后，将`dummyHead2 `插入到`dummyHead1 `后面
+### 动画描述
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181104095701.gif)
+### 代码实现
+```
+class Solution {
+public:
+    ListNode* partition(ListNode* head, int x) {
+        ListNode* dummyHead1 = new ListNode(-1);
+        ListNode* dummyHead2 = new ListNode(-1);
+        ListNode* prev1 = dummyHead1;
+        ListNode* prev2 = dummyHead2;
+        for(ListNode* cur = head ; cur != NULL ;){
+            if(cur->val < x){
+                prev1->next = cur;
+                cur = cur->next;
+                prev1 = prev1->next;
+                prev1->next = NULL;
+            }
+            else{
+                prev2->next = cur;
+                cur = cur->next;
+                prev2 = prev2->next;
+                prev2->next = NULL;
+            }
+        }
+        prev1->next = dummyHead2->next;
+        ListNode* ret = dummyHead1->next;
+        delete dummyHead1;
+        delete dummyHead2;
+        return ret;
+    }
+};
+```
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/fz0rq.png)
\ No newline at end of file
--- a/LeetCode 第 877 号问题：石子游戏.md
+++ b/LeetCode 第 877 号问题：石子游戏.md
+# LeetCode 第 877 号问题：石子游戏
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+### 题目描述
+喜羊羊和灰太狼用几堆石子在做游戏。偶数堆石子**排成一行**，每堆都有正整数颗石子 `piles[i]` 。
+游戏以谁手中的石子最多来决出胜负。石子的总数是奇数，所以没有平局。
+喜羊羊和灰太狼轮流进行，喜羊羊先开始。 每回合，玩家从行的开始或结束处取走整堆石头。 这种情况一直持续到没有更多的石子堆为止，此时手中石子最多的玩家获胜。
+假设喜羊羊和灰太狼都发挥出最佳水平，当喜羊羊赢得比赛时返回 `true` ，当灰太狼赢得比赛时返回 `false` 。
+### 题目分析
+举两个例子来帮助理解题意。
+#### 例子一：
+输入：[ 5，3，4，5 ]
+输出：true
+**解释**：
+喜羊羊先开始，只能拿前 5 颗或后 5 颗石子 。
+假设他取了前 5 颗，这一行就变成了 [ 3 ，4，5 ] 。
+如果灰太狼拿走前 3 颗，那么剩下的是 [ 4，5 ]，喜羊羊拿走后 5 颗赢得 10 分。
+如果灰太狼拿走后 5 颗，那么剩下的是 [ 3，4 ]，喜羊羊拿走后 4 颗赢得 9 分。
+这表明，取前 5 颗石子对喜羊羊来说是一个胜利的举动，所以我们返回 true 。
+#### 例子二：
+输入：[ 5，10000，2，3 ]
+输出：true
+**解释**：
+喜羊羊先开始，只能拿前 5 颗或后 3 颗石子 。
+假设他取了后 3 颗，这一行就变成了 [ 5，10000，2 ]。
+灰太狼肯定会在剩下的这一行中取走前 5 颗，这一行就变成了 [ 10000，2 ]。
+然后喜羊羊取走前 10000 颗，总共赢得 10003 分，灰太狼赢得 7 分。
+这表明，取后 3 颗石子对喜羊羊来说是一个胜利的举动，所以我们返回 true 。
+**这个例子表明，并不是需要每次都挑选最大的那堆石头**。
+### 题目回答
+涉及到最优解的问题，那么肯定要去尝试一下使用 **动态规划 **来解决了。
+先看一下力扣的正规题解：
+让我们改变游戏规则，使得每当灰太狼得分时，都会从喜羊羊的分数中扣除。
+令 `dp(i, j)` 为喜羊羊可以获得的最大分数，其中剩下的堆中的石子数是 `piles[i], piles[i+1], ..., piles[j]`。这在比分游戏中很自然：我们想知道游戏中每个位置的值。
+我们可以根据 `dp(i + 1，j)` 和 `dp(i，j-1)` 来制定 `dp(i，j)` 的递归，我们可以使用动态编程以不重复这个递归中的工作。（该方法可以输出正确的答案，因为状态形成一个DAG（有向无环图）。）
+当剩下的堆的石子数是 `piles[i], piles[i+1], ..., piles[j]` 时，轮到的玩家最多有 2 种行为。
+可以通过比较 `j-i`和 `N modulo 2` 来找出轮到的人。
+如果玩家是喜羊羊，那么它将取走 `piles[i]` 或 `piles[j]` 颗石子，增加它的分数。之后，总分为 `piles[i] + dp(i+1, j)` 或 `piles[j] + dp(i, j-1)`；我们想要其中的最大可能得分。
+如果玩家是灰太狼，那么它将取走 `piles[i]` 或 `piles[j]` 颗石子，减少喜羊羊这一数量的分数。之后，总分为 `-piles[i] + dp(i+1, j)` 或 `-piles[j] + dp(i, j-1)`；我们想要其中的最小可能得分。
+代码如下：
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20190502124645.jpg)
+上面的代码并不算复杂，当然，如果你看不懂也没关系，不影响解决问题，请看下面的数学分析。
+### 数学分析
+因为石头的数量是奇数，因此只有两种结果，输或者赢。
+喜羊羊先开始拿石头，随便拿！然后比较石头数量：
+1. 如果石头数量多于对手，赢了；
+2. 如果石头数量少于对手，自己拿石头的顺序和对手拿石头的顺序对调，还是赢。
+所以代码如下：
+```java
+class Solution {
+    public boolean stoneGame(int[] piles) {
+        return true;
+    }
+}
+```
+看完之后，你的心情是怎么样的？
+此题的LeetCode 的评论区里一片吐槽：**这是什么沙雕题目！**
+可能搞过 ACM 等竞赛的人都会微微一笑：不会几万个套路怎么好意思说自己是 acmer 。我们这些普通人为之惊奇的题目，到他们这里就是彻底被玩坏了，各种稀奇古怪的秒解。
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/fz0rq.png)
\ No newline at end of file
--- a/LeetCode 第 92 号问题：反转链表 II.md
+++ b/LeetCode 第 92 号问题：反转链表 II.md
+# LeetCode 第 92 号问题：反转链表 II
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+题目来源于 LeetCode 上第 92 号问题：反转链表 II。题目难度为 Medium，目前通过率为 43.8% 。
+### 题目描述
+反转从位置 *m* 到 *n* 的链表。请使用一趟扫描完成反转。
+**说明:**
+1 ≤ *m* ≤ *n* ≤ 链表长度。
+**示例:**
+```
+输入: 1->2->3->4->5->NULL, m = 2, n = 4
+输出: 1->4->3->2->5->NULL
+```
+### 题目解析
+**[Reverse Linked List](https://xiaozhuanlan.com/topic/7513064892)**的延伸题。
+可以考虑取出需要反转的这一小段链表，反转完后再插入到原先的链表中。
+**以本题为例：**
+变换的是 2，3，4这三个点，那么我们可以先取出 2 ，用 front 指针指向 2 ，然后当取出 3 的时候，我们把 3 加到 2 的前面，把 front 指针前移到 3 ，依次类推，到 4 后停止，这样我们得到一个新链表 4 -> 3 -> 2 ,  front 指针指向4。
+对于原链表来说，**有两个点的位置很重要**，需要用指针记录下来，分别是 1 和 5 ，把新链表插入的时候需要这两个点的位置。
+- 用 pre 指针记录 1 的位置
+- 当 4 结点被取走后，5 的位置需要记下来
+- 这样我们就可以把倒置后的那一小段链表加入到原链表中
+### 动画描述
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181103160226.gif)
+### 代码实现
+```
+class Solution {
+public:
+    ListNode *reverseBetween(ListNode *head, int m, int n) {
+        ListNode *dummy = new ListNode(-1);
+        dummy->next = head;
+        ListNode *cur = dummy;
+        ListNode *pre, *front, *last;
+        for (int i = 1; i <= m - 1; ++i) cur = cur->next;
+        pre = cur;
+        last = cur->next;
+        for (int i = m; i <= n; ++i) {
+            cur = pre->next;
+            pre->next = cur->next;
+            cur->next = front;
+            front = cur;
+        }
+        cur = pre->next;
+        pre->next = front;
+        last->next = cur;
+        return dummy->next;
+    }
+};
+```
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/fz0rq.png)
\ No newline at end of file
--- a/LeetCode 第 94 号问题：二叉树的中序遍历.md
+++ b/LeetCode 第 94 号问题：二叉树的中序遍历.md
+# LeetCode 第 94 号问题：二叉树的中序遍历
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+题目来源于 LeetCode 上第 94 号问题：二叉树的中序遍历。题目难度为 Medium，目前通过率为 35.8% 。
+### 题目描述
+给定一个二叉树，返回它的*中序* 遍历。
+**示例:**
+```
+输入: [1,null,2,3]
+   1
+    \
+     2
+    /
+   3
+输出: [1,3,2]
+```
+**进阶:** 递归算法很简单，你可以通过迭代算法完成吗？
+### 题目解析
+用**栈(Stack)**的思路来处理问题。
+中序遍历的顺序为**左-根-右**，具体算法为：
+- 从根节点开始，先将根节点压入栈
+- 然后再将其所有左子结点压入栈，取出栈顶节点，保存节点值
+- 再将当前指针移到其右子节点上，若存在右子节点，则在下次循环时又可将其所有左子结点压入栈中
+### 动画描述
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20190502102629.gif)
+### 代码实现
+```
+class Solution {
+        public List<Integer> inorderTraversal(TreeNode root) {
+            List<Integer> list = new ArrayList<>();
+            Stack<TreeNode> stack = new Stack<>();
+            TreeNode cur = root;
+            while (cur != null || !stack.isEmpty()) {
+                if (cur != null) {
+                    stack.push(cur);
+                    cur = cur.left;
+                } else {
+                    cur = stack.pop();
+                    list.add(cur.val);
+                    cur = cur.right;
+                }
+            }
+            return list;
+        }
+}
+```
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/fz0rq.png)
\ No newline at end of file
--- a/Readme.md
+++ b/Readme.md
@@ -6,64 +6,67 @@
 [There is an English version of README here. just click it！](https://github.com/MisterBooo/LeetCodeAnimation/blob/master/README-En.md)
-我会尽力将LeetCode上所有的题目都用动画的形式演示出来，计划用3到4年时间去完成它，期待与你见证这一天！
+我会尽力将 LeetCode 上所有的题目都用动画的形式演示出来，计划用 3 到 4 年时间去完成它，期待与你见证这一天！
 文章最新首发于微信公众号 **五分钟学算法** ，您可以关注获取最新的文章。
+### 汇总
-## Problems
+| 序号 | 题目&题解                                                    |
+| ---- | ------------------------------------------------------------ |
+| 0    | [十大经典排序算法动画与解析，看我就够了！（配代码完全版）](https://mp.weixin.qq.com/s/vn3KiV-ez79FmbZ36SX9lg) |
-| ID | Problem  | Article | Animation |Date|
+| 1    | [两数之和](LeetCode 第 1 号问题：两数之和)                   |
-| --- | ---  | :--- |:--- |:---  |
+| 2    | [两数相加](LeetCode 第 2 号问题：两数相加)                   |
-| 000 |十大经典排序算法 | [十大经典排序算法动画与解析，看我就够了！（配代码完全版）](https://mp.weixin.qq.com/s/vn3KiV-ez79FmbZ36SX9lg) | ![归并排序.gif](https://upload-images.jianshu.io/upload_images/1940317-92f62b62af03e233.gif?imageMogr2/auto-orient/strip)||
+| 3    | [无重复字符的最长子串](LeetCode 第 3 号问题：无重复字符的最长子串) |
-| 001 |两数之和 | [每天一算：Two Sum](https://mp.weixin.qq.com/s?__biz=MzUyNjQxNjYyMg==&mid=2247483740&idx=1&sn=1950545589ea9b86ee65fbb6be1f4290&chksm=fa0e6eddcd79e7cb542b7d4dc1304eead516994315fa4f52b575230f0f022c9e0a88ede3714e&scene=21#wechat_redirect) |![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181206161033.gif) ||
+| 15   | [三数之和](LeetCode 第 15 号问题：三数之和)                  |
-| 002 |两个数字相加 | [图解LeetCode第 2 号问题：两个数字相加](https://mp.weixin.qq.com/s?__biz=MzUyNjQxNjYyMg==&mid=2247484231&idx=2&sn=6a9eb4fd0619c822e4dede69b8d841c8&chksm=fa0e6cc6cd79e5d0c03fffcd65b665fed62db9dca9c97771898f388ea292ce806bfd6eb908b5&token=934487935&lang=zh_CN#rd)  |![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181210092831.gif)||
+| 19   | [删除链表的倒数第 N 个节点](LeetCode 第 19 号问题：删除链表的倒数第 N 个节点) |
-| 003 |无重复字符的最长子串| [图解LeetCode第 3 号问题：无重复字符的最长子串](https://mp.weixin.qq.com/s?__biz=MzUyNjQxNjYyMg==&mid=2247484265&idx=2&sn=7f72afb341865923315bd51e1f50beff&chksm=fa0e6ce8cd79e5fe4be925fd5f01f59f59010c6c965fb3daefac79992593a6e58990c212e0bb&token=1412967663&lang=zh_CN#rd)|![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181210092855.gif)||
+| 20   | [有效的括号](LeetCode 第 20 号问题：有效的括号)              |
-| 019| 删除链表的倒数第N个节点 |[每天一算：Remove Nth Node From End of List](http://mp.weixin.qq.com/s?__biz=MzUyNjQxNjYyMg==&mid=2247483821&idx=1&sn=11ecccab76cd53163e9dedb75effeb93&chksm=fa0e6e2ccd79e73ae9137c0d91b3533df4ea4ead4ad081834b8d91ff364c0d55c350ddcfa6c4&scene=21#wechat_redirect)  |![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181206161058.gif)||
+| 21   | [合并两个有序链表](LeetCode 第 21 号问题：合并两个有序链表)  |
-| 020|有效的括号  | [每天一算：Valid Parentheses](http://mp.weixin.qq.com/s?__biz=MzUyNjQxNjYyMg==&mid=2247483824&idx=1&sn=ab9362e125dc5e2b3ef1611cad9448c2&chksm=fa0e6e31cd79e727c6e1e0e3c467e193edb6ae841a41e5dc8eef39d0bf3141cc53f63b019cba&scene=21#wechat_redirect) |![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181206161106.gif)||
+| 23   | [合并 K 个排序链表](LeetCode 第 23 号问题：合并 K 个排序链表) |
-| 024| 两两交换链表中的节点 | [每天一算：Swap Nodes in Pairs](http://mp.weixin.qq.com/s?__biz=MzUyNjQxNjYyMg==&mid=2247483773&idx=1&sn=db6cf272df968cd6571eb0bb50ecc721&chksm=fa0e6efccd79e7ea26810d335e6ece9ac23b8e3ac31be00dbd534018737ccb3ef9a00f22aff3&scene=21#wechat_redirect) |![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181206161115.gif)||
+| 24   | [两两交换链表中的节点](LeetCode 第 24 号问题：两两交换链表中的节点) |
-| 026|  删除排序数组中的重复项| [图解LeetCode第 26 号问题：删除排序数组中的重复项](https://mp.weixin.qq.com/s?__biz=MzUyNjQxNjYyMg==&mid=2247484284&idx=2&sn=c8af62a82a62a21217d0f0b2b5891e4f&chksm=fa0e6cfdcd79e5ebe8726a61f93b834467d29b7d9e60a44feb990388f9e98605ac1e3f7e723d&token=762342620&lang=zh_CN#rd) |![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181206161124.gif)||
+| 26   | [删除排序数组中的重复项](LeetCode 第 26 号问题：删除排序数组中的重复项) |
-| 075|  颜色分类| [每天一算：Sort Colors](http://mp.weixin.qq.com/s?__biz=MzUyNjQxNjYyMg==&mid=2247483706&idx=1&sn=905f43c882a91b55fd169d812620f277&chksm=fa0e6ebbcd79e7ad8857b0dad9ad14dbaf17fe557ef56ba600cec26b2bb668df2e171431d74c&scene=21#wechat_redirect) |![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181206161136.gif)||
+| 75   | [颜色分类](LeetCode 第 75 号问题：颜色分类)                  |
-| 086|  分隔链表| 	[每天一算：Partition List](http://mp.weixin.qq.com/s?__biz=MzUyNjQxNjYyMg==&mid=2247483781&idx=1&sn=f31548ebbb2cf9ba56d979d3e51ddde2&chksm=fa0e6e04cd79e712d6cc7ff8e8b7631b7300ac0fa1a3e4c4e3b836de7a01fb5d0d6428a18bc4&scene=21#wechat_redirect) |![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181206161147.gif)||
+| 86   | [分割链表](LeetCode 第 86 号问题：分割链表)                  |
-|092 |反转链表 II  | [每天一算：Reverse Linked List II](http://mp.weixin.qq.com/s?__biz=MzUyNjQxNjYyMg==&mid=2247483820&idx=1&sn=113e87b55c8ac8e22e9db00673798118&chksm=fa0e6e2dcd79e73b5835a262599b935783de3317a453bc0ed8df9fa5d1532785a085ea663e59&scene=21#wechat_redirect) |![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181206161156.gif)||
+| 92   | [反转链表 II](LeetCode 第 92 号问题：反转链表 II)            |
-| 094|二叉树的中序遍历  | [每天一算：Binary Tree Inorder Traversal ](http://mp.weixin.qq.com/s?__biz=MzUyNjQxNjYyMg==&mid=2247483853&idx=1&sn=94cd4b4ee8dc2268290a72334c6af57b&chksm=fa0e6e4ccd79e75a41a6b78397b80cdfccda332823874475b516f997f89e786488599fc5cc1e&scene=21#wechat_redirect)|![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181206161208.gif)||
+| 94   | [二叉树的中序遍历](LeetCode 第 94 号问题：二叉树的中序遍历)  |
-|102	|二叉树的层序遍历|	[每天一算：Binary Tree Level Order Traveral](http://mp.weixin.qq.com/s?__biz=MzUyNjQxNjYyMg==&mid=2247483868&idx=1&sn=d50041789fcd13a75a2296f620b69d71&chksm=fa0e6e5dcd79e74b0030ac5129f10ec4ba87c98da63c5904affe9f06e06ecf28695c410d3ec7&scene=21#wechat_redirect)|![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181206161232.gif)||
+| 101  | [对称二叉树](LeetCode 第 101 号问题：对称二叉树)             |
-|103	|	二叉树的锯齿形层次遍历|	[图解LeetCode第 103 号问题：二叉树的锯齿形层次遍历](https://mp.weixin.qq.com/s?__biz=MzUyNjQxNjYyMg==&mid=2247484290&idx=2&sn=c29c4eefcbe8954cca6b3c8491ebccf1&chksm=fa0e6c03cd79e515581905322a3a22a3f3d10d24ca668a9d5aaef00932f0237eeaeaf3199668&token=1840661183&lang=zh_CN#rd)|![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181210092922.gif)||
+| 102  | [二叉树的层序遍历](LeetCode 第 102 号问题：二叉树的层序遍历) |
-|107	| 二叉树的层次遍历 II  |	每天一算： Binary Tree Level Order Traversal II|![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181210092949.gif)||
+| 103  | [二叉树的锯齿形层次遍历](LeetCode 第 103 号问题：二叉树的锯齿形层次遍历) |
-|136	| 只出现一次的数字 |	[一道让你拍案叫绝的算法题 ](https://mp.weixin.qq.com/s?__biz=MzUyNjQxNjYyMg==&mid=2247484505&idx=1&sn=4c1c056dd4852c3b4b1ead51c90a9b2d&chksm=fa0e6bd8cd79e2ce8188dcdd8843a5d071248906bfb8971c62d513dbd69b816acc191a78e4b2&token=487128715&lang=zh_CN#rd)|![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20190116110804.gif)| 2019-01-16 |
+| 107  | [二叉树的层次遍历 II](LeetCode 第 107 号问题：二叉树的层次遍历 II) |
-|144 |  二叉树的前序遍历|  [每天一算：Binary Tree Preorder Traversal](http://mp.weixin.qq.com/s?__biz=MzUyNjQxNjYyMg==&mid=2247483843&idx=1&sn=994bf0d42dd9941a879a3a3ed500a4d6&chksm=fa0e6e42cd79e75472404eb5da7ee98f20d303efe230eb4f41efec57164630f555e7111e62ff&scene=21#wechat_redirect)|![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181207112441.gif)||
+| 110  | [平衡二叉树](LeetCode 第 110 号问题：平衡二叉树)             |
-| 145| 二叉树的后序遍历 | [每天一算：Binary Tree Postorder Traversal](https://mp.weixin.qq.com/s?__biz=MzUyNjQxNjYyMg==&mid=2247483861&idx=1&sn=91a32b22ab9bc7fd282b489c4d3006e0&chksm=fa0e6e54cd79e742e22a0b15d4eb55b933de19bb12d2de41fac19fc59da6c8e3cc65dea2120c&token=647916903&lang=zh_CN#rd) |![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181219084940.gif)||
+| 125  | [验证回文串](LeetCode 第 125 号问题：验证回文串)             |
-| 146| LRU缓存机制 |  LRU缓存机制 |![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20190125143756.gif)| 2019-01-25 Made by Jun chen|
+| 131  | [分割回文串](LeetCode 第 131 号问题：分割回文串)             |
-| 150| 逆波兰表达式求值 | [每天一算：Evaluate Reverse Polish Notation](http://mp.weixin.qq.com/s?__biz=MzUyNjQxNjYyMg==&mid=2247483834&idx=1&sn=27cbff99f10dfcdb56cb37c237d7f2bb&chksm=fa0e6e3bcd79e72dc430bf81aed9dde9bd01634239dcf7820d6befa881efd323d9d58d76d90d&scene=21#wechat_redirect) |![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181206161304.gif)||
+| 136  | [只出现一次的数字](LeetCode 第 136 号问题：只出现一次的数字) |
-| 167| 两数之和 II - 输入有序数组 | [每天一算：Two Sum II ](http://mp.weixin.qq.com/s?__biz=MzUyNjQxNjYyMg==&mid=2247483711&idx=1&sn=3afec74e9e9effa71dc0b22659e14b44&chksm=fa0e6ebecd79e7a84db7861c9b5dbccdc98aa9d9a6994dda49a37edeb729e8242ea6af8f20ad&scene=21#wechat_redirect)|![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181206161314.gif)||
+| 138  | [复制带随机指针](LeetCode 第 138 号问题：复制带随机指针)     |
-|199 | 二叉树的右视图 | 每天一算：Binary Tree Right Side View |![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181206161328.gif)||
+| 139  | [单词拆分](LeetCode 第 139 号问题：单词拆分)                 |
-| 203| 移除链表元素 |  [每天一算：Remove Linked List Elements](http://mp.weixin.qq.com/s?__biz=MzUyNjQxNjYyMg==&mid=2247483766&idx=1&sn=6721376a65680bf7cf9064cf7b1ae4ae&chksm=fa0e6ef7cd79e7e1665e60fe6ea3f2087bca518c1573bc4c4b9425573f98401bafc59542dca0&scene=21#wechat_redirect)|![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181206161338.gif)||
+| 144  | [二叉树的前序遍历](LeetCode 第 144 号问题：二叉树的前序遍历) |
-|206	| 	反转链表 |	[每天一算： Reverse Linked List](http://mp.weixin.qq.com/s?__biz=MzUyNjQxNjYyMg==&mid=2247483799&idx=1&sn=c2212c8963809e8d3392abeeb851dbfc&chksm=fa0e6e16cd79e7003c2d30b1a2bb4f23dc56df38e3efedd0ab2cfae291609280a832eabe67de&scene=21#wechat_redirect)|![](https://diycode.b0.upaiyun.com/photo/2018/0e0b3a4b1031c3bcf16bd1240ebc571a.gif)||
+| 145  | [二叉树的后序遍历](LeetCode 第 145 号问题：二叉树的后序遍历) |
-|209	| 	长度最小的子数组  |	每天一算： Minimum Size Subarray Sum |![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181210093031.gif)||
+| 146  | [LRU缓存机制](LeetCode 第 146 号问题：LRU缓存机制)           |
-| 219|存在重复元素 II  |[每天一算：Contains Duplicate II  ](http://mp.weixin.qq.com/s?__biz=MzUyNjQxNjYyMg==&mid=2247483755&idx=1&sn=2501b6ca09c43eaa9fba71a9bd1f5253&chksm=fa0e6eeacd79e7fc192c0a23cf90d98fe6f2c35f9e4f2d0f937ccba45a58cf23a0a9c49d35d5&scene=21#wechat_redirect)|![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181206161352.gif)||
+| 150  | [逆波兰表达式求值](LeetCode 第 150 号问题：逆波兰表达式求值) |
-|237|	删除链表中的节点	|每天一算：Delete Node in a Linked List|![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181206161400.gif) ||
+| 167  | [两数之和 II - 输入有序数组](LeetCode 第 167 号问题：两数之和 II - 输入有序数组) |
-|279|	完全平方数	|[图解LeetCode第 279 号问题： 完全平方数](https://mp.weixin.qq.com/s/53AlHe29fJF1hEwj0cj7ZA)|![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20190119213317.gif) |  Made by 王琛 2019-01-19日|
+| 187  | [重复的 DNA 序列](LeetCode 第 187 号问题：重复的 DNA 序列)   |
-|283	|移动零	|[每天一算：Move Zeros](http://mp.weixin.qq.com/s?__biz=MzUyNjQxNjYyMg==&mid=2247483700&idx=1&sn=465f778d60e8560742feab5844d7cac5&chksm=fa0e6eb5cd79e7a357899d378edb532b498cd63e3ce9113f8ac74d397ce4b214ca5aa8198b7d&scene=21#wechat_redirect)|![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181206161421.gif)||
+| 199  | [二叉树的右视图](LeetCode 第 199 号问题：二叉树的右视图)     |
-|328 |奇偶链表  | [每天一算：Odd Even Linked List](http://mp.weixin.qq.com/s?__biz=MzUyNjQxNjYyMg==&mid=2247483786&idx=1&sn=f7810950b34675e1c4420361faf5e361&chksm=fa0e6e0bcd79e71d2c6fc6a4a68b6ef7a17abc3dc9897548f8e44b51e9494f52c4cebbc4176e&scene=21#wechat_redirect) |![](https://diycode.b0.upaiyun.com/photo/2018/94e5c38540029690c93314b3d697caaf.gif)||
+| 203  | [移除链表元素](LeetCode 第 203 号问题：移除链表元素)         |
-|344 | 反转字符串 |每天一算：Reverse String |![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181211110918.gif)||
+| 206  | [反转链表](LeetCode 第 206 号问题：反转链表)                 |
-|349 |  两个数组的交集| [每天一算：Intersection of Two Arrays ](http://mp.weixin.qq.com/s?__biz=MzUyNjQxNjYyMg==&mid=2247483726&idx=1&sn=a887f6b983058d97c183dd300832ecbb&chksm=fa0e6ecfcd79e7d985587b543622c85aadc83a4d7a074135e1356fb4a0ebfd07e7af13467906&scene=21#wechat_redirect)|![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181206161441.gif)||
+| 209  | [长度最小的子数组](LeetCode 第 209 号问题：长度最小的子数组) |
-| 350|  两个数组的交集 II| [每天一算：Intersection of Two Arrays II ](http://mp.weixin.qq.com/s?__biz=MzUyNjQxNjYyMg==&mid=2247483733&idx=1&sn=946bd6de3251437dd77b43ecab056c82&chksm=fa0e6ed4cd79e7c2a439b5f1853bf5154a3438ed282c7ba5e94948780c426a1f1492c0b201c4&scene=21#wechat_redirect)|![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181206161729.gif)||
+| 219  | [存在重复元素 II](LeetCode 第 219 号问题：存在重复元素 II)   |
-|445|	两数相加 II	|[图解LeetCode第 445 号问题：  两数相加 II](https://mp.weixin.qq.com/s/z8_1dK7mw9gxfhhSZUBVgg)|![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20190119213714.gif) |  Made by 王琛 2019-01-19日|
+| 237  | [删除链表中的节点](LeetCode 第 237 号问题：删除链表中的节点) |
-|447 | 回旋镖的数量 |  [每日一算：Number of Boomerangs](http://mp.weixin.qq.com/s?__biz=MzUyNjQxNjYyMg==&mid=2247483747&idx=1&sn=7774eee0b252b311257134f6a52c4e2d&chksm=fa0e6ee2cd79e7f44858c46c3d04859ced9073dbb9de95ce7ee0bcc131e613862ddfd9a6f158&scene=21#wechat_redirect)|![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181206161738.gif)||
+| 239  | [滑动窗口最大值](LeetCode 第 239 号问题：滑动窗口最大值)     |
-|454 |四数相加 II  |  每日一算：4Sum II|![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181206161751.gif)||
+| 279  | [完全平方数](LeetCode 第 279 号问题：完全平方数)             |
-|642 |设计搜索自动补全系统  |  [图解 LeetCode 第 642 号问题：搜索自动完成系统](https://mp.weixin.qq.com/s?__biz=MzUyNjQxNjYyMg==&mid=2247484491&idx=1&sn=b329d90370d183b5a58bbf03f6a436ae&chksm=fa0e6bcacd79e2dc05bb5eaabd888561b82c37700b511e4971aa76ec42a630c0a35ef3e4721b&token=397665543&lang=zh_CN#rd)|动画是采用AE制作，内存太大，无法使用GIF播放，请前往[动画](https://mp.weixin.qq.com/s?__biz=MzUyNjQxNjYyMg==&mid=2247484491&idx=1&sn=b329d90370d183b5a58bbf03f6a436ae&chksm=fa0e6bcacd79e2dc05bb5eaabd888561b82c37700b511e4971aa76ec42a630c0a35ef3e4721b&token=397665543&lang=zh_CN#rd)观看，感谢 Jun Chen 大佬提供动画技术支持，笔芯。||
+| 283  | [移动零](LeetCode 第 283 号问题：移动零)                     |
+| 295  | [数据流的中位数](LeetCode 第 295 号问题：数据流的中位数)     |
+| 301  | [删除无效的括号](LeetCode 第 301 号问题：删除无效的括号)     |
-如果文章链接无法点击，说明文章还未发布，敬请期待：）
+| 326  | [3 的幂](LeetCode 第 326 号问题：3 的幂)                     |
+| 328  | [奇偶链表](LeetCode 第 328 号问题：奇偶链表)                 |
-为了让文章加载动画更快，录制动画时进行了压缩，有可能会模糊，如果你想获取上述文章的所有超清动画，请在公众号 **五分钟学算法** 内回复 **MP4** 进行获取。
+| 344  | [反转字符串](LeetCode 第 344 号问题：反转字符串)             |
+| 349  | [两个数组的交集](LeetCode 第 349 号问题：两个数组的交集)     |
-## 代码来源声明
+| 350  | [两个数组的交集 II](LeetCode 第 350 号问题：两个数组的交集 II) |
-本仓库代码如无特殊说明，全部来源于此仓库
+| 445  | [两数相加 II](LeetCode 第 445 号问题：两数相加 II)           |
+| 447  | [回旋镖的数量](LeetCode 第 447 号问题：回旋镖的数量)         |
-[Play-Leetcode](https://github.com/liuyubobobo/Play-Leetcode)
+| 454  | [四数相加 II](LeetCode 第 454 号问题：四数相加 II)           |
+| 642  | [设计一个搜索自动完成系统](LeetCode 第 642 号问题：设计一个搜索自动完成系统) |
+| 690  | [员工的重要性](LeetCode 第 690 号问题：员工的重要性)         |
+| 877  | [石子游戏](LeetCode 第 877 号问题：石子游戏)                 |
 ## 补充
 该仓库保持随时更新。
@@ -82,11 +85,13 @@
 喜欢就star❤️一下吧！
 ## 和我交流
 | 二维码 |  说明 |
 | --- | ---  |
-|![](https://diycode.b0.upaiyun.com/photo/2018/6ac660d9a4a36db44c404246ba858862.jpg) |  关注公众号 **五分钟学算法** 获取更多数据结构与动画相关的内容|
+|![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/fz0rq.png) | 欢迎前来和程序员小吴一起学算法 |