添加更多文章动画

LeetCode 第 2 号问题：两数相加.md

+# LeetCode 第 2 号问题：两数相加
+
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+
+题目来源于 LeetCode 上第 2 号问题：两数相加。题目难度为 Medium，目前通过率为 33.9% 。
+
+### 题目描述
+
+给出两个 **非空** 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 **逆序** 的方式存储的，并且它们的每个节点只能存储 **一位** 数字。
+
+如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
+
+您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
+
+**示例：**
+
+```
+输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
+输出：7 -> 0 -> 8
+原因：342 + 465 = 807
+```
+
+### 题目解析
+
+设立一个表示进位的变量`carried`，建立一个新链表，把输入的两个链表从头往后同时处理，每两个相加，将结果加上`carried`后的值作为一个新节点到新链表后面。
+
+### 动画描述
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181117122234.gif)
+
+### 代码实现
+
+```
+/// 时间复杂度: O(n)
+/// 空间复杂度: O(n)
+class Solution {
+public:
+    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
+
+        ListNode *p1 = l1, *p2 = l2;
+        ListNode *dummyHead = new ListNode(-1);
+        ListNode* cur = dummyHead;
+        int carried = 0;
+        while(p1 || p2 ){
+            int a = p1 ? p1->val : 0;
+            int b = p2 ? p2->val : 0;
+            cur->next = new ListNode((a + b + carried) % 10);
+            carried = (a + b + carried) / 10;
+
+            cur = cur->next;
+            p1 = p1 ? p1->next : NULL;
+            p2 = p2 ? p2->next : NULL;
+        }
+
+        cur->next = carried ? new ListNode(1) : NULL;
+        ListNode* ret = dummyHead->next;
+        delete dummyHead;
+        return ret;
+    }
+};
+
+```
+
+
+
+
+
+
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/fz0rq.png)
\ No newline at end of file

LeetCode 第 20 号问题：有效的括号.md

+# LeetCode 第 20 号问题：有效的括号
+
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+
+题目来源于 LeetCode 上第 20 号问题：有效的括号。题目难度为 Easy，目前通过率为 37.8% 。
+
+### 题目描述
+
+给定一个只包括 `'('`，`')'`，`'{'`，`'}'`，`'['`，`']'` 的字符串，判断字符串是否有效。
+
+有效字符串需满足：
+
+1. 左括号必须用相同类型的右括号闭合。
+2. 左括号必须以正确的顺序闭合。
+
+注意空字符串可被认为是有效字符串。
+
+**示例 1:**
+
+```
+输入: "()"
+输出: true
+```
+
+**示例 2:**
+
+```
+输入: "()[]{}"
+输出: true
+```
+
+**示例 3:**
+
+```
+输入: "(]"
+输出: false
+```
+
+**示例 4:**
+
+```
+输入: "([)]"
+输出: false
+```
+
+**示例 5:**
+
+```
+输入: "{[]}"
+输出: true
+```
+
+### 题目解析
+
+这道题让我们验证输入的字符串是否为括号字符串，包括大括号，中括号和小括号。
+
+这里我们使用**栈**。
+
+- 遍历输入字符串
+- 如果当前字符为左半边括号时，则将其压入栈中
+- 如果遇到右半边括号时，**分类讨论：**
+- 1）如栈不为空且为对应的左半边括号，则取出栈顶元素，继续循环  
+- 2）若此时栈为空，则直接返回false
+- 3）若不为对应的左半边括号，反之返回false
+
+### 动画描述
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181108111124.gif)
+
+### 代码实现
+
+```
+class Solution {
+public:
+    bool isValid(string s) {
+
+        stack<char> stack;
+        for( int i = 0 ; i < s.size() ; i ++ )
+            if( s[i] == '(' || s[i] == '{' || s[i] == '[')
+                stack.push(s[i]);
+            else{
+
+                if( stack.size() == 0 )
+                    return false;
+
+                char c = stack.top();
+                stack.pop();
+
+                char match;
+                if( s[i] == ')' ){
+                    match = '(';
+                }
+                else if( s[i] == ']' ){
+                    match = '[';
+                }
+                else{
+                    match = '{';
+                }
+
+                if(c != match)  return false;
+            }
+
+        if( stack.size() != 0 )
+            return false;
+
+        return true;
+    }
+};
+```
+
+
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/fz0rq.png)
\ No newline at end of file

LeetCode 第 203 号问题：移除链表元素.md

+# LeetCode 第 203 号问题：移除链表元素
+
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+
+题目来源于 LeetCode 上第 203 号问题：移除链表元素。题目难度为 Easy，目前通过率为 55.8% 。
+
+### 题目描述
+
+删除链表中等于给定值 **val** 的所有节点。
+
+**示例:**
+
+```
+输入: 1->2->6->3->4->5->6, val = 6
+输出: 1->2->3->4->5
+```
+
+### 题目解析
+
+主要考察了基本的链表遍历和设置指针的知识点。
+
+定义一个虚拟头节点`dummyHead `，遍历查看原链表，遇到与给定值相同的元素，将该元素的前后两个节点连接起来，然后删除该元素即可。
+
+### 动画描述
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181102163006.gif)
+
+### 代码实现
+
+#### 代码一
+
+```
+// 203. Remove Linked List Elements
+// https://leetcode.com/problems/remove-linked-list-elements/description/
+// 使用虚拟头结点
+// 时间复杂度: O(n)
+// 空间复杂度: O(1)
+class Solution {
+public:
+    ListNode* removeElements(ListNode* head, int val) {
+
+        // 创建虚拟头结点
+        ListNode* dummyHead = new ListNode(0);
+        dummyHead->next = head;
+
+        ListNode* cur = dummyHead;
+        while(cur->next != NULL){
+            if(cur->next->val == val){
+                ListNode* delNode = cur->next;
+                cur->next = delNode->next;
+                delete delNode;
+            }
+            else
+                cur = cur->next;
+        }
+
+        ListNode* retNode = dummyHead->next;
+        delete dummyHead;
+
+        return retNode;
+    }
+};
+
+```
+
+#### 代码二
+
+用递归来解。
+
+通过递归调用到链表末尾，然后回来，需要删的元素，将链表next指针指向下一个元素即可。
+
+```
+class Solution {
+public:
+    ListNode* removeElements(ListNode* head, int val) {
+        if (!head) return NULL;
+        head->next = removeElements(head->next, val);
+        return head->val == val ? head->next : head;
+    }
+};
+```
+
+## 
+
+
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/fz0rq.png)
\ No newline at end of file

LeetCode 第 206 号问题：反转链表.md

+# LeetCode 第 206 号问题：反转链表
+
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+
+题目来源于 LeetCode 上第 206 号问题：反转链表。题目难度为 Easy，目前通过率为 45.8% 。
+
+### 题目描述
+
+反转一个单链表。
+
+**示例:**
+
+```
+输入: 1->2->3->4->5->NULL
+输出: 5->4->3->2->1->NULL
+```
+
+**进阶:**
+你可以迭代或递归地反转链表。你能否用两种方法解决这道题？
+
+### 题目解析
+
+设置三个节点`pre`、`cur`、`next`
+
+- （1）每次查看`cur`节点是否为`NULL`，如果是，则结束循环，获得结果
+- （2）如果`cur`节点不是为`NULL`，则先设置临时变量`next`为`cur`的下一个节点
+- （3）让`cur`的下一个节点变成指向`pre`，而后`pre`移动`cur`，`cur`移动到`next`
+- （4）重复（1）（2）（3）
+
+### 动画描述
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181101175158.gif)
+
+### 代码实现
+
+```
+class Solution {
+public:
+    ListNode* reverseList(ListNode* head) {
+        ListNode* pre = NULL;
+        ListNode* cur = head;
+        while(cur != NULL){
+            ListNode* next = cur->next;
+            cur->next = pre;
+            pre = cur;
+            cur = next;
+        }
+
+        return pre;
+    }
+};
+```
+
+
+
+
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/fz0rq.png)
\ No newline at end of file

LeetCode 第 209 号问题：长度最小的子数组.md

+# LeetCode 第 209 号问题：长度最小的子数组
+
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+
+题目来源于 LeetCode 上第 209 号问题：长度最小的子数组。题目难度为 Medium，目前通过率为 25.8% 。
+
+### 题目描述
+
+给定一个含有 **n** 个正整数的数组和一个正整数 **s ，**找出该数组中满足其和 **≥ s** 的长度最小的连续子数组**。**如果不存在符合条件的连续子数组，返回 0。
+
+**示例:** 
+
+```
+输入: s = 7, nums = [2,3,1,2,4,3]
+输出: 2
+解释: 子数组 [4,3] 是该条件下的长度最小的连续子数组。
+```
+
+**进阶:**
+
+如果你已经完成了*O*(*n*) 时间复杂度的解法, 请尝试 *O*(*n* log *n*) 时间复杂度的解法。
+
+### 题目解析
+
+定义两个指针 left 和 right ，分别记录子数组的左右的边界位置。
+
+
+* （1）让 right 向右移，直到子数组和大于等于给定值或者 right 达到数组末尾；
+
+* （2）更新最短距离，将 left 像右移一位,sum 减去移去的值；
+
+* （3）重复（1）（2）步骤，直到 right 到达末尾，且 left 到达临界位置
+
+
+
+### 动画描述
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181027160331.gif)
+
+设置滑动窗口的长度为 0 ，位于数轴的最左端。
+
+##### 1 .滑动窗口右端 R 开始移动，直到区间满足给定的条件，也就是和大于 7 ，此时停止于第三个元素 2，当前的最优长度为 4
+
+![图 1](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/8rr0w.jpg)
+
+
+
+##### 2. 滑动窗口左端 L 开始移动，缩小滑动窗口的大小，停止于第一个元素 3，此时区间和为 6，使得区间和不满足给定的条件（此时不大于 7）
+
+![图片 2](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/77oa4.jpg)
+
+
+
+#### 3. 滑动窗口右端 R 继续移动，停止于第四个元素 4，此时和位 10 ，但最优长度仍然为 4
+
+![图片 3](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/8ksiz.jpg)
+
+
+
+### 代码实现
+
+```
+// 滑动窗口的思路
+// 时间复杂度: O(n)
+// 空间复杂度: O(1)
+class Solution {
+    public int minSubArrayLen(int s, int[] nums) {
+        int l= 0,r = -1;    // nums[l...r]为我们的滑动窗口
+        int sum = 0;
+        int result = nums.length + 1;
+        while (l < nums.length){ // 窗口的左边界在数组范围内,则循环继续
+
+            if( r+1 <nums.length && sum < s){
+                r++;
+                sum += nums[r];
+            }else { // r已经到头 或者 sum >= s
+                sum -= nums[l];
+                l++;
+            }
+
+            if(sum >= s){
+                result = (r-l+1) < result ? (r-l+1) : result ;
+            }
+        }
+        if(result==nums.length+1){
+            return 0;
+        }
+        return result;
+    }
+}
+
+```
+
+
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/fz0rq.png)
\ No newline at end of file

LeetCode 第 21 号问题：合并两个有序链表.md

+# LeetCode 第 21 号问题：合并两个有序链表
+
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+
+题目来源于 LeetCode 上第 21 号问题：合并两个有序链表。题目难度为 Easy，目前通过率为 45.8% 。
+
+### 题目描述
+
+将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 
+
+**示例：**
+
+```
+输入：1->2->4, 1->3->4
+输出：1->1->2->3->4->4
+```
+
+### 题目解析
+
+####  一般方案
+
+##### 1.1 解题思想
+
+> （1）对空链表存在的情况进行处理，假如 pHead1 为空则返回 pHead2 ，pHead2 为空则返回 pHead1。（两个都为空此情况在pHead1为空已经被拦截）
+> （2）在两个链表无空链表的情况下确定第一个结点，比较链表1和链表2的第一个结点的值，将值小的结点保存下来为合并后的第一个结点。并且把第一个结点为最小的链表向后移动一个元素。
+> （3）继续在剩下的元素中选择小的值，连接到第一个结点后面，并不断next将值小的结点连接到第一个结点后面，直到某一个链表为空。
+> （4）当两个链表长度不一致时，也就是比较完成后其中一个链表为空，此时需要把另外一个链表剩下的元素都连接到第一个结点的后面。
+
+##### 1.2 代码实现
+
+```c++
+ListNode* mergeTwoOrderedLists(ListNode* pHead1, ListNode* pHead2){
+    ListNode* pTail = NULL;//指向新链表的最后一个结点 pTail->next去连接
+    ListNode* newHead = NULL;//指向合并后链表第一个结点
+    if (NULL == pHead1){
+        return pHead2;
+    }else if(NULL == pHead2){
+        return pHead1;
+    }else{
+        //确定头指针
+        if ( pHead1->data < pHead2->data){
+            newHead = pHead1;
+            pHead1 = pHead1->next;//指向链表的第二个结点
+        }else{
+            newHead = pHead2;
+            pHead2 = pHead2->next;
+        }
+        pTail = newHead;//指向第一个结点
+        while ( pHead1 && pHead2) {
+            if ( pHead1->data <= pHead2->data ){
+                pTail->next = pHead1;  
+                pHead1 = pHead1->next;
+            }else {
+                pTail->next = pHead2;
+                pHead2 = pHead2->next;
+            }
+            pTail = pTail->next;
+
+        }
+        if(NULL == pHead1){
+            pTail->next = pHead2;
+        }else if(NULL == pHead2){
+            pTail->next = pHead1;
+        }
+        return newHead;
+}
+```
+
+#### 2 递归方案
+
+##### 2.1 解题思想
+
+> （1）对空链表存在的情况进行处理，假如 pHead1 为空则返回 pHead2 ，pHead2 为空则返回 pHead1。
+> （2）比较两个链表第一个结点的大小，确定头结点的位置
+> （3）头结点确定后，继续在剩下的结点中选出下一个结点去链接到第二步选出的结点后面，然后在继续重复（2 ）（3） 步，直到有链表为空。
+
+##### 2.2 代码实现
+
+```c++
+ListNode* mergeTwoOrderedLists(ListNode* pHead1, ListNode* pHead2){
+    ListNode* newHead = NULL;
+    if (NULL == pHead1){
+        return pHead2;
+    }else if(NULL ==pHead2){
+        return pHead2;
+    }else{
+        if (pHead1->data < pHead2->data){
+            newHead = pHead1;
+            newHead->next = mergeTwoOrderedLists(pHead1->next, pHead2);
+        }else{
+            newHead = pHead2;
+            newHead->next = mergeTwoOrderedLists(pHead1, pHead2->next);
+         }
+        return newHead;
+    }   
+}
+```
+
+### 
+
+
+
+
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/fz0rq.png)
\ No newline at end of file

LeetCode 第 219 号问题：存在重复元素 II.md

+# LeetCode 第 219 号问题：存在重复元素 II
+
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+
+题目来源于 LeetCode 上第 219 号问题：存在重复元素 II。题目难度为 Easy，目前通过率为 34.8% 。
+
+### 题目描述
+
+给定一个整数数组和一个整数 *k*，判断数组中是否存在两个不同的索引 *i* 和 *j*，使得 **nums [i] = nums [j]**，并且 *i* 和 *j* 的差的绝对值最大为 *k*。
+
+**示例 1:**
+
+```
+输入: nums = [1,2,3,1], k = 3
+输出: true
+```
+
+**示例 2:**
+
+```
+输入: nums = [1,0,1,1], k = 1
+输出: true
+```
+
+**示例 3:**
+
+```
+输入: nums = [1,2,3,1,2,3], k = 2
+输出: false
+```
+
+### 题目解析
+
+考虑用滑动窗口与查找表来解决。
+
+* 设置查找表`record`，用来保存每次遍历时插入的元素，`record `的最大长度为`k `
+* 遍历数组`nums`，每次遍历的时候在`record `查找是否存在相同的元素，如果存在则返回`true`，遍历结束
+* 如果此次遍历在`record `未查找到，则将该元素插入到`record `中，而后查看`record `的长度是否为`k + 1`
+* 如果此时`record `的长度是否为`k + 1`，则删减`record`的元素，该元素的值为`nums[i - k]`
+* 如果遍历完整个数组`nums`未查找到则返回`false`
+
+### 动画描述
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181031104805.gif)
+
+### 代码实现
+
+```
+// 219. Contains Duplicate II
+// https://leetcode.com/problems/contains-duplicate-ii/description/
+// 时间复杂度: O(n)
+// 空间复杂度: O(k)
+class Solution {
+public:
+    bool containsNearbyDuplicate(vector<int>& nums, int k) {
+
+        if(nums.size() <= 1)  return false;
+
+        if(k <= 0)  return false;
+        
+
+        unordered_set<int> record;
+        for(int i = 0 ; i < nums.size() ; i ++){
+
+            if(record.find(nums[i]) != record.end()){
+                return true;
+            }
+
+            record.insert(nums[i]);
+
+            // 保持record中最多有k个元素
+            // 因为在下一次循环中会添加一个新元素,使得总共考虑k+1个元素
+            if(record.size() == k + 1){
+                record.erase(nums[i - k]);
+            }
+        }
+
+        return false;
+    }
+};
+```
+
+
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/fz0rq.png)
\ No newline at end of file

LeetCode 第 23 号问题：合并 K 个排序链表.md

+# LeetCode 第 23 号问题：合并 K 个排序链表
+
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+
+题目来源于 LeetCode 上第 23 号问题：合并 K 个排序链表。题目难度为 Hard，目前通过率为 45.8% 。
+
+### 题目描述
+
+合并 *k* 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。
+
+**示例:**
+
+```
+输入:
+[
+  1->4->5,
+  1->3->4,
+  2->6
+]
+输出: 1->1->2->3->4->4->5->6
+```
+
+**输入**
+
+![图一](https://user-gold-cdn.xitu.io/2019/4/9/169ff8cbaf694440?w=2360&h=614&f=jpeg&s=63179)
+
+**输出**
+
+![图二](https://user-gold-cdn.xitu.io/2019/4/9/169ff8cbb372e71f?w=2518&h=572&f=jpeg&s=62543)
+
+### 题目解析
+
+### 题目分析一
+
+这里需要将这 *k* 个排序链表整合成一个排序链表，也就是说有多个输入，一个输出，类似于漏斗一样的概念。
+
+因此，可以利用最小堆的概念。如果你对堆的概念不熟悉，可以戳这先了解一下~
+
+取每个 Linked List 的最小节点放入一个 heap 中，排序成最小堆。然后取出堆顶最小的元素，放入输出的合并 List 中，然后将该节点在其对应的 List 中的下一个节点插入到 heap 中，循环上面步骤，以此类推直到全部节点都经过 heap。
+
+由于 heap 的大小为始终为 k ，而每次插入的复杂度是 logk ，一共插入了 nk 个节点。时间复杂度为 O(nklogk)，空间复杂度为O(k)。
+
+### 动画演示
+
+![动画演示](https://user-gold-cdn.xitu.io/2019/4/9/169ff8cbb36cb6f7?w=939&h=507&f=gif&s=6542126)
+
+### 代码实现
+
+```java
+class Solution {
+    public ListNode mergeKLists(ListNode[] lists) {
+        //用heap(堆)这种数据结构，也就是 java 里面的 PriorityQueue
+        PriorityQueue<ListNode> pq = new PriorityQueue<>(new Comparator<ListNode>() {
+            public int compare(ListNode a, ListNode b) {
+                return a.val-b.val;
+            }
+        });
+        ListNode ret = null, cur = null;
+        for(ListNode node: lists) {
+            if(null != node) {
+                pq.add(node);    
+            }
+        }
+        while(!pq.isEmpty()) {
+            ListNode node = pq.poll();
+            if(null == ret) {
+                ret = cur = node;
+            }
+            else {
+                cur = cur.next = node;
+            }
+            if(null != node.next) {
+                pq.add(node.next);    
+            }
+        }
+        return ret;
+    }
+}
+```
+
+
+
+
+
+### 题目分析二
+
+这道题需要合并 k 个有序链表，并且最终合并出来的结果也必须是有序的。如果一开始没有头绪的话，可以先从简单的开始：**合并 两 个有序链表**。
+
+合并两个有序链表：将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 
+
+**示例：**
+
+```
+输入：1->2->4, 1->3->4
+输出：1->1->2->3->4->4
+```
+
+这道题目按照题目描述做下去就行：新建一个链表，比较原始两个链表中的元素值，把较小的那个链到新链表中即可。需要注意的一点时由于两个输入链表的长度可能不同，所以最终会有一个链表先完成插入所有元素，则直接另一个未完成的链表直接链入新链表的末尾。
+
+所以代码实现很容易写：
+
+```java
+class Solution {
+    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
+        //新建链表
+        ListNode dummyHead = new ListNode(0);
+        ListNode cur = dummyHead;
+        while (l1 != null && l2 != null) {
+            if (l1.val < l2.val) {
+                cur.next = l1;
+                cur = cur.next;
+                l1 = l1.next;
+            } else {
+                cur.next = l2;
+                cur = cur.next;
+                l2 = l2.next;
+            }
+        }
+        // 注意点：当有链表为空时，直接连接另一条链表
+        if (l1 == null) {
+            cur.next = l2;
+        } else {
+            cur.next = l1;
+        }
+        return dummyHead.next;
+    }
+```
+
+
+
+现在回到一开始的题目：合并 K 个排序链表。
+
+**合并 K 个排序链表** 与 **合并两个有序链表** 的区别点在于操作有序链表的数量上，因此完全可以按照上面的代码思路来实现合并 K 个排序链表。
+
+这里可以参考 **归并排序 **的分治思想，将这  K 个链表先划分为两个 K/2 个链表，处理它们的合并，然后不停的往下划分，直到划分成只有一个或两个链表的任务，开始合并。
+
+![归并-分治](https://user-gold-cdn.xitu.io/2019/4/9/169ff8cbb2c891fe?w=953&h=531&f=gif&s=164652)
+
+### 代码实现
+
+根据上面的动画，实现代码非常简单也容易理解，先划分，直到不能划分下去，然后开始合并。
+
+```java
+class Solution {
+    public ListNode mergeKLists(ListNode[] lists){
+        if(lists.length == 0)
+            return null;
+        if(lists.length == 1)
+            return lists[0];
+        if(lists.length == 2){
+           return mergeTwoLists(lists[0],lists[1]);
+        }
+
+        int mid = lists.length/2;
+        ListNode[] l1 = new ListNode[mid];
+        for(int i = 0; i < mid; i++){
+            l1[i] = lists[i];
+        }
+
+        ListNode[] l2 = new ListNode[lists.length-mid];
+        for(int i = mid,j=0; i < lists.length; i++,j++){
+            l2[j] = lists[i];
+        }
+
+        return mergeTwoLists(mergeKLists(l1),mergeKLists(l2));
+
+    }
+    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
+        if (l1 == null) return l2;
+        if (l2 == null) return l1;
+
+        ListNode head = null;
+        if (l1.val <= l2.val){
+            head = l1;
+            head.next = mergeTwoLists(l1.next, l2);
+        } else {
+            head = l2;
+            head.next = mergeTwoLists(l1, l2.next);
+        }
+        return head;
+    }
+}
+```
+
+
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/fz0rq.png)
\ No newline at end of file

LeetCode 第 237 号问题：删除链表中的节点.md

+# LeetCode 第 237 号问题：删除链表中的节点
+
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+
+题目来源于 LeetCode 上第 237 号问题：删除链表中的节点。题目难度为 Easy，目前通过率为 72.6% 。
+
+### 题目描述
+
+请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点。
+
+现有一个链表 -- head = [4,5,1,9]，它可以表示为:
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20190502113234.png)
+
+ 
+
+**示例 1:**
+
+```
+输入: head = [4,5,1,9], node = 5
+输出: [4,1,9]
+解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.
+```
+
+**示例 2:**
+
+```
+输入: head = [4,5,1,9], node = 1
+输出: [4,5,9]
+解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.
+```
+
+ 
+
+**说明:**
+
+- 链表至少包含两个节点。
+- 链表中所有节点的值都是唯一的。
+- 给定的节点为非末尾节点并且一定是链表中的一个有效节点。
+- 不要从你的函数中返回任何结果。
+
+### 题目解析
+
+此题注意的点是没有给我们链表的起点，只给我们了一个要删的节点，与以往处理的情况稍许不同。
+
+**这道题的处理方法是先把当前节点的值用下一个节点的值覆盖，然后我们删除下一个节点即可**
+
+### 动画描述
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181105171450.gif)
+
+### 代码实现
+
+```
+class Solution {
+public:
+    void deleteNode(ListNode* node) {
+        if (node == NULL) return;
+        if (node->next == NULL) {
+            delete node;
+            node = NULL;
+            return;
+        }
+        node->val = node->next->val;
+        ListNode *delNode = node->next;
+        node->next = delNode->next;
+        
+        delete delNode;
+    }
+};
+```
+
+
+
+
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/fz0rq.png)
\ No newline at end of file

LeetCode 第 239 号问题：滑动窗口最大值.md

+# LeetCode 第 239 号问题：滑动窗口最大值
+
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+
+题目来源于 LeetCode 上第 239 号问题：滑动窗口最大值。题目难度为 Hard，目前通过率为 40.5% 。
+
+### 题目描述
+
+给定一个数组 *nums*，有一个大小为 *k* 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口 *k* 内的数字。滑动窗口每次只向右移动一位。
+
+返回滑动窗口最大值。
+
+**示例:**
+
+```
+输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3
+输出: [3,3,5,5,6,7] 
+解释: 
+
+  滑动窗口的位置                最大值
+---------------               -----
+[1  3  -1] -3  5  3  6  7       3
+ 1 [3  -1  -3] 5  3  6  7       3
+ 1  3 [-1  -3  5] 3  6  7       5
+ 1  3  -1 [-3  5  3] 6  7       5
+ 1  3  -1  -3 [5  3  6] 7       6
+ 1  3  -1  -3  5 [3  6  7]      7
+```
+
+**注意：**
+
+你可以假设 *k* 总是有效的，1 ≤ k ≤ 输入数组的大小，且输入数组不为空。
+
+**进阶：**
+
+你能在线性时间复杂度内解决此题吗？
+
+### 题目解析
+
+利用一个 **双端队列**，在队列中存储元素在数组中的位置， 并且维持队列的严格递减,，也就说维持队首元素是 **最大的 **，当遍历到一个新元素时, 如果队列里有比当前元素小的，就将其移除队列，以保证队列的递减。当队列元素位置之差大于 k，就将队首元素移除。
+
+### 补充：什么是双端队列（Dqueue）
+
+Deque 的含义是 “double ended queue”，即双端队列，它具有队列和栈的性质的数据结构。顾名思义，它是一种前端与后端都支持插入和删除操作的队列。
+
+Deque 继承自 Queue（队列），它的直接实现有 ArrayDeque、LinkedList 等。
+
+### 
+
+
+
+### 动画描述
+
+![动画描述 Made by Jun Chen](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/20whr.gif)
+
+### 代码实现
+
+```
+class Solution {
+   public int[] maxSlidingWindow(int[] nums, int k) {
+        //有点坑，题目里都说了数组不为空，且 k > 0。但是看了一下，测试用例里面还是有nums = [], k = 0，所以只好加上这个判断
+        if (nums == null || nums.length < k || k == 0) return new int[0];
+        int[] res = new int[nums.length - k + 1];
+        //双端队列
+        Deque<Integer> deque = new LinkedList<>();
+        for (int i = 0; i < nums.length; i++) {
+            //在尾部添加元素，并保证左边元素都比尾部大
+            while (!deque.isEmpty() && nums[deque.getLast()] < nums[i]) {
+                deque.removeLast();
+            }
+            deque.addLast(i);
+            //在头部移除元素
+            if (deque.getFirst() == i - k) {
+                deque.removeFirst();
+            }
+            //输出结果
+            if (i >= k - 1) {
+                res[i - k + 1] = nums[deque.getFirst()];
+            }
+        }
+        return res;
+     }
+}
+```
+
+
+
+
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/fz0rq.png)
\ No newline at end of file

LeetCode 第 24 号问题：两两交换链表中的节点.md

+# LeetCode 第 24 号问题：两两交换链表中的节点
+
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+
+题目来源于 LeetCode 上第 24 号问题：两两交换链表中的节点。题目难度为 Medium，目前通过率为 45.8% 。
+
+### 题目描述
+
+给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
+
+**你不能只是单纯的改变节点内部的值**，而是需要实际的进行节点交换。
+
+**示例:**
+
+```
+给定 1->2->3->4, 你应该返回 2->1->4->3.
+```
+
+### 题目解析
+
+该题属于基本的链表操作题。
+
+- 设置一个虚拟头结点`dummyHead `
+- 设置需要交换的两个节点分别为`node1 `、`node2`，同时设置`node2`的下一个节点`next`
+
+##### 在这一轮操作中
+
+- 将`node2`节点的next设置为`node1`节点
+- 将`node1`节点的next设置为`next `节点
+- 将`dummyHead `节点的next设置为`node2 `
+- 结束本轮操作
+
+接下来的每轮操作都按照上述进行。
+
+### 动画描述
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181103145019.gif)
+
+### 代码实现
+
+```
+// 24. Swap Nodes in Pairs
+// https://leetcode.com/problems/swap-nodes-in-pairs/description/
+// 时间复杂度: O(n)
+// 空间复杂度: O(1)
+class Solution {
+public:
+    ListNode* swapPairs(ListNode* head) {
+
+        ListNode* dummyHead = new ListNode(0);
+        dummyHead->next = head;
+
+        ListNode* p = dummyHead;
+        while(p->next && p->next->next){
+            ListNode* node1 = p->next;
+            ListNode* node2 = node1->next;
+            ListNode* next = node2->next;
+            node2->next = node1;
+            node1->next = next;
+            p->next = node2;
+            p = node1;
+        }
+
+        ListNode* retHead = dummyHead->next;
+        delete dummyHead;
+
+        return retHead;
+    }
+};
+
+```
+
+
+
+
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/fz0rq.png)
\ No newline at end of file

LeetCode 第 26 号问题：删除排序数组中的重复项.md

+# LeetCode 第 26 号问题：删除排序数组中的重复项
+
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+
+题目来源于 LeetCode 上第 26 号问题：删除排序数组中的重复项。题目难度为 Easy，目前通过率为 48.8% 。
+
+### 题目描述
+
+给定一个排序数组，你需要在**原地**删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。
+
+不要使用额外的数组空间，你必须在**原地修改输入数组**并在使用 O(1) 额外空间的条件下完成。
+
+**示例 1:**
+
+```
+给定数组 nums = [1,1,2], 
+
+函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。 
+
+你不需要考虑数组中超出新长度后面的元素。
+```
+
+**示例 2:**
+
+```
+给定 nums = [0,0,1,1,1,2,2,3,3,4],
+
+函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。
+
+你不需要考虑数组中超出新长度后面的元素。
+```
+
+**说明:**
+
+为什么返回数值是整数，但输出的答案是数组呢?
+
+请注意，输入数组是以**“引用”**方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。
+
+你可以想象内部操作如下:
+
+```
+// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
+int len = removeDuplicates(nums);
+
+// 在函数里修改输入数组对于调用者是可见的。
+// 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。
+for (int i = 0; i < len; i++) {
+    print(nums[i]);
+}
+```
+
+### 题目解析
+
+使用快慢指针来记录遍历的坐标。
+
+- 开始时这两个指针都指向第一个数字
+- 如果两个指针指的数字相同，则快指针向前走一步
+- 如果不同，则两个指针都向前走一步
+- 当快指针走完整个数组后，慢指针当前的坐标加1就是数组中不同数字的个数
+
+### 动画描述
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181116115601.gif)
+
+
+
+### 代码实现
+
+```
+class Solution {
+public:
+    int removeDuplicates(vector<int>& nums) {
+        if (nums.empty()) return 0;
+        int pre = 0, cur = 0, n = nums.size();
+        while (cur < n) {
+            if (nums[pre] == nums[cur]){
+              cur++;  
+            } else{
+                ++pre;
+                nums[pre] = nums[cur];
+                cur++;
+            } 
+        }
+        return pre + 1;
+    }
+};
+```
+
+
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/fz0rq.png)
\ No newline at end of file

LeetCode 第 279 号问题：完全平方数.md

+# LeetCode 第 279 号问题：完全平方数
+
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+
+题目来源于 LeetCode 上第 279 号问题：完全平方数。题目难度为 Medium，目前通过率为 49.1% 。
+
+### 题目描述
+
+给定正整数 *n*，找到若干个完全平方数（比如 `1, 4, 9, 16, ...`）使得它们的和等于 *n*。你需要让组成和的完全平方数的个数最少。
+
+**示例 1:**
+
+```
+输入: n = 12
+输出: 3 
+解释: 12 = 4 + 4 + 4.
+```
+
+**示例 2:**
+
+```
+输入: n = 13
+输出: 2
+解释: 13 = 4 + 9.
+```
+
+### 题目解析
+
+这道题目很有意思。
+
+大部分文章给出的答案都是依托于一个定理：**四平方定理**。
+
+四平方定理讲的就是任何一个正整数都可以表示成不超过四个整数的平方之和。也就是说，这道题的答案只有 1，2 ，3，4 这四种可能。
+
+同时，还有一个非常重要的推论满足四数平方和定理的数n（这里要满足由四个数构成，小于四个不行），必定满足 n = 4<sup>a</sup> * (8b + 7)。
+
+根据这个重要的推论来解决此题，首先将输入的`n`迅速缩小。然后再判断，这个缩小后的数是否可以通过`两个平方数的和或一个平方数`组成，不能的话我们返回`3`，能的话我们返回`平方数的个数`。
+
+所以代码很简洁，如下：
+
+```java
+public int numSquares(int n) {
+        while (n % 4 == 0){
+            n /= 4;
+        }
+        if ( n % 8 == 7){
+            return 4;
+        }
+        int a = 0;
+        while ( (a * a) <= n){
+            int b = (int)Math.pow((n - a * a),0.5);
+             if(a * a + b * b == n) {
+            //如果可以 在这里返回
+            if(a != 0 && b != 0) {
+                return 2;
+            } else{
+                return 1;
+            }
+        }
+        a++;
+     }
+        return 3;
+}
+```
+
+
+
+但因为本章是「广度优先遍历」的专栏，因此再补充一个图的广度优先遍历的答案：
+
+使用广度优先搜索方法，将 n 依次减去比 n 小的所有平方数，直至 n = 0 ，此时的层数即为最后的结果。
+
+### 动画描述
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20190502113958.gif)
+
+### 代码实现
+
+```
+import java.util.LinkedList;
+import javafx.util.Pair;
+class Solution {
+    public int numSquares(int n) {
+         if(n == 0)
+            return 0;
+            
+        LinkedList<Pair<Integer, Integer>> queue = new LinkedList<Pair<Integer, Integer>>();
+        queue.addLast(new Pair<Integer, Integer>(n, 0));
+
+        boolean[] visited = new boolean[n+1];
+        visited[n] = true;
+
+        while(!queue.isEmpty()){
+            Pair<Integer, Integer> front = queue.removeFirst();
+            int num = front.getKey();
+            int step = front.getValue();
+
+            if(num == 0)
+                return step;
+
+            for(int i = 1 ; num - i*i >= 0 ; i ++){
+                int a = num - i*i;
+                if(!visited[a]){
+                    if(a == 0) return step + 1;
+                    queue.addLast(new Pair(num - i * i, step + 1));
+                    visited[num - i * i] = true;
+                }
+            }
+        }
+        return 0;
+    }
+}
+```
+
+
+
+
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/fz0rq.png)
\ No newline at end of file

LeetCode 第 283 号问题：移动零.md

+# LeetCode 第 283 号问题：移动零
+
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+
+题目来源于 LeetCode 上第 283 号问题：移动零。题目难度为 Easy，目前通过率为 53.8% 。
+
+### 题目描述
+
+给定一个数组 `nums`，编写一个函数将所有 `0` 移动到数组的末尾，同时保持非零元素的相对顺序。
+
+**示例:**
+
+```
+输入: [0,1,0,3,12]
+输出: [1,3,12,0,0]
+```
+
+**说明**:
+
+1. 必须在原数组上操作，不能拷贝额外的数组。
+2. 尽量减少操作次数。
+
+### 题目解析
+
+设定一个临时变量 k = 0，遍历数组 nums ，将非零元素移动到 nums[k]位 置，同时 k++，而后将【k,….nums.size()】中的元素置零。
+
+### 解法一
+
+创建一个临时数组 nonZeroElements ，遍历 nums ，将 nums 中非 0 元素赋值到 nonZeroElements中，而后按顺序将 nonZeroElements 赋值到 nums 上，未遍历的元素置 0 ；
+
+动画如下：
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181027160100.gif)
+
+代码如下：
+
+```
+// 时间复杂度: O(n)
+// 空间复杂度: O(n)
+class Solution {
+public:
+    void moveZeroes(vector<int>& nums) {
+
+        vector<int> nonZeroElements;
+
+        // 将vec中所有非0元素放入nonZeroElements中
+        for(int i = 0 ; i < nums.size() ; i ++)
+            if(nums[i])
+                nonZeroElements.push_back(nums[i]);
+
+        // 将nonZeroElements中的所有元素依次放入到nums开始的位置
+        for(int i = 0 ; i < nonZeroElements.size() ; i ++)
+            nums[i] = nonZeroElements[i];
+
+        // 将nums剩余的位置放置为0
+        for(int i = nonZeroElements.size() ; i < nums.size() ; i ++)
+            nums[i] = 0;
+    }
+};
+
+```
+
+### 解法二
+
+设定一个临时变量 k = 0，遍历数组 nums ，将非零元素移动到 nums[k] 位置，同时 k++，而后将【k,….nums.size()】中的元素置零。
+
+动画如下：
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181027160135.gif)
+
+代码如下：
+
+```
+// 原地(in place)解决该问题
+// 时间复杂度: O(n)
+// 空间复杂度: O(1)
+class Solution {
+public:
+    void moveZeroes(vector<int>& nums) {
+
+        int k = 0; // nums中, [0...k)的元素均为非0元素
+
+        // 遍历到第i个元素后,保证[0...i]中所有非0元素
+        // 都按照顺序排列在[0...k)中
+        for(int i = 0 ; i < nums.size() ; i ++)
+            if(nums[i])
+                nums[k++] = nums[i];
+
+        // 将nums剩余的位置放置为0
+        for(int i = k ; i < nums.size() ; i ++)
+            nums[i] = 0;
+    }
+};
+```
+
+### 解法三
+
+思路：设定一个临时变量 k = 0，遍历数组 nums，将非零元素与之前的零元素进行交换，维护变量k的值。
+
+动画如下：
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181030085904.gif)
+代码如下：
+
+```
+// 原地(in place)解决该问题
+// 时间复杂度: O(n)
+// 空间复杂度: O(1)
+class Solution {
+public:
+    void moveZeroes(vector<int>& nums) {
+
+        int k = 0; // nums中, [0...k)的元素均为非0元素
+
+        // 遍历到第i个元素后,保证[0...i]中所有非0元素
+        // 都按照顺序排列在[0...k)中
+        // 同时, [k...i] 为 0
+        for(int i = 0 ; i < nums.size() ; i ++)
+            if(nums[i]){
+                if(k != i){
+                    swap(nums[k++] , nums[i]);
+                }else{
+                    k ++;
+                }
+            }
+        }
+};
+
+```
+
+
+
+
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/fz0rq.png)
\ No newline at end of file

LeetCode 第 295 号问题：数据流的中位数.md

+# LeetCode 第 295 号问题：数据流的中位数
+
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+
+题目来源于 LeetCode 上第 295 号问题：数据流的中位数。难度级别为 Hard，目前通过率为 33.5% 。
+
+### 题目描述
+
+中位数是有序列表中间的数。如果列表长度是偶数，中位数则是中间两个数的平均值。
+
+例如，
+
+[2,3,4] 的中位数是 3
+
+[2,3] 的中位数是 (2 + 3) / 2 = 2.5
+
+设计一个支持以下两种操作的数据结构：
+
+- void addNum(int num) - 从数据流中添加一个整数到数据结构中。
+- double findMedian() - 返回目前所有元素的中位数。
+
+**示例：**
+
+```java
+addNum(1)
+addNum(2)
+findMedian() -> 1.5
+addNum(3) 
+findMedian() -> 2
+```
+
+
+
+### 题目解析
+
+这道题给我们一个数据流，让我们找出中位数。对于数据流这种动态（流动）的数据，如果使用数组存储，那么每次新进来一个数据都进行排序的话，效率很低。
+
+处理动态数据来说一般使用的数据结构是栈、队列、二叉树、堆。
+
+本题中，我们使用 **堆** 这种数据结构。
+
+首先将数据分为两部分，位于 **上边最大堆** 的数据要比 **下边最小堆** 的数据都要小。
+
+为了保证将数据平均分配到两个堆中，在动态的操作的过程中两个堆中数据的数目之差不能超过 1。
+
+为了保证 **最大堆中的所有数据都小于最小堆中的数据**，在操作过程中，新添加进去的数据需要先和最大堆的最大值或者最小堆中的最小值进行比较。
+
+### 动画描述
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20190502114925.gif)
+
+### 代码实现
+
+
+
+```java
+class MedianFinder {
+    public PriorityQueue<Integer> minheap, maxheap;
+    public MedianFinder() {
+        //维护较大的元素的最小堆
+        maxheap = new PriorityQueue<Integer>(Collections.reverseOrder());
+        //维护较小元素的最大堆
+        minheap = new PriorityQueue<Integer>();
+    }
+    
+    // Adds a number into the data structure.
+    public void addNum(int num) {
+        maxheap.add(num);
+        minheap.add(maxheap.poll());
+        if (maxheap.size() < minheap.size()) {
+            maxheap.add(minheap.poll());
+        }
+    }
+
+    // Returns the median of current data stream
+    public double findMedian() {
+        if (maxheap.size() == minheap.size()) {
+            return (maxheap.peek() + minheap.peek()) * 0.5;
+        } else {
+            return maxheap.peek();
+        }
+    }
+};
+```
+
+
+
+
+
+
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/fz0rq.png)
\ No newline at end of file

LeetCode 第 3 号问题：无重复字符的最长子串.md

+# LeetCode 第 3 号问题：无重复字符的最长子串
+
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+
+题目来源于 LeetCode 上第 3 号问题：无重复字符的最长子串。题目难度为 Medium，目前通过率为 29.0% 。
+
+### 题目描述
+
+给定一个字符串，请你找出其中不含有重复字符的 **最长子串** 的长度。
+
+**示例 1:**
+
+```java
+输入: "abcabcbb"
+输出: 3 
+解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
+```
+
+### 题目解析
+
+建立一个256位大小的整型数组 freg ，用来建立字符和其出现位置之间的映射。
+
+维护一个滑动窗口，窗口内的都是没有重复的字符，去尽可能的扩大窗口的大小，窗口不停的向右滑动。
+
+- （1）如果当前遍历到的字符从未出现过，那么直接扩大右边界；
+- （2）如果当前遍历到的字符出现过，则缩小窗口（左边索引向右移动），然后继续观察当前遍历到的字符；
+- （3）重复（1）（2），直到左边索引无法再移动；
+- （4）维护一个结果res，每次用出现过的窗口大小来更新结果 res，最后返回 res 获取结果。
+
+### 动画描述
+
+![动画描述](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/o2acw.gif)
+
+### 代码实现
+
+```c++
+// 滑动窗口
+// 时间复杂度: O(len(s))
+// 空间复杂度: O(len(charset))
+class Solution {
+public:
+    int lengthOfLongestSubstring(string s) {
+        int freq[256] = {0};
+        int l = 0, r = -1; //滑动窗口为s[l...r]
+        int res = 0;
+        // 整个循环从 l == 0; r == -1 这个空窗口开始
+        // 到l == s.size(); r == s.size()-1 这个空窗口截止
+        // 在每次循环里逐渐改变窗口, 维护freq, 并记录当前窗口中是否找到了一个新的最优值
+        while(l < s.size()){
+            if(r + 1 < s.size() && freq[s[r+1]] == 0){
+                r++;
+                freq[s[r]]++;
+            }else {   //r已经到头 || freq[s[r+1]] == 1
+                freq[s[l]]--;
+                l++;
+            }
+            res = max(res, r-l+1);
+        }
+        return res;
+    }
+};
+```
+

LeetCode 第 301 号问题：删除无效的括号.md

+# LeetCode 第 301 号问题：删除无效的括号
+
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+
+题目来源于 LeetCode 第 301 号问题：删除无效的括号。有小伙伴后台留言说这题是中山大学计算机考研机试题。
+
+### 题目描述
+
+删除最小数量的无效括号，使得输入的字符串有效，返回所有可能的结果。
+
+**说明:** 输入可能包含了除 `(` 和 `)` 以外的字符。
+
+**示例 1:**
+
+```
+输入: "()())()"
+输出: ["()()()", "(())()"]
+```
+
+**示例 2:**
+
+```
+输入: "(a)())()"
+输出: ["(a)()()", "(a())()"]
+```
+
+**示例 3:**
+
+```
+输入: ")("
+输出: [""]
+```
+
+
+
+### 题目解析
+
+所谓有效的括号，那么字符串中的左右括号数应该相同，而且每个右括号左边一定有其对应的左括号。这里很容易想到使用一个栈来模拟匹配过程，'(' 入栈，')' 出栈，若栈为空说明该串是符合题意的。
+
+首先对括号进行删除，遍历从前往后遍历可以删除不符合的 ')' 括号，从后往前遍历可以删除不符合的'('括号，通过 BFS，不断的对队列的字符串进行 checkLeft 和 checkRight 操作，若遇到 ture，则说明当前的字符串已经是删除最少无效的括号的最优解了，接着就对队列中的其他字符串进行 check 即可。
+这道题目的动画与 LeetCode 第 20 号问题--有效的括号很类似，这里就拿出来进行参考理解一下，区别点就在于多了遍历和哈希存储。
+
+### 动画描述
+
+待补充
+
+### 代码实现
+
+```
+
+public class Solution {
+    public List<String> removeInvalidParentheses(String s) {
+        queue.offer(s);
+        vis.add(s);
+        boolean flag=false;
+        List<String> ans=new ArrayList<String>();
+        while (!queue.isEmpty()){
+            String cur=queue.poll();
+            if(flag){
+                check(cur,ans);
+            }else{
+                flag=checkLeft(cur,ans)||checkRight(cur,ans);
+            }
+        }
+        if(ans.size()==0){
+            ans.add("");
+        }
+        return new ArrayList<String>(ans);
+    }
+
+    Set<String> vis=new HashSet<String>();
+    Queue<String> queue=new LinkedList<String>();
+
+    public void check(String s,List<String> ans){  //查看是否正确
+        Stack<Character> st=new Stack<Character>();
+        for(char c:s.toCharArray()){
+            if(c=='('){
+                st.push(c);
+            }
+            if(c==')'){
+                if(st.isEmpty()){
+                    return;
+                }
+                st.pop();
+            }
+        }
+        if(st.isEmpty()){
+            ans.add(s);
+        }
+    }
+
+    public boolean checkLeft(String s,List<String> ans){ //检查左边
+        //delete right
+        Stack<Character> st=new Stack<Character>();
+        for(int i=0;i<s.length();++i){
+            if(s.charAt(i)=='('){
+                st.push(s.charAt(i));
+            }else if(s.charAt(i)==')'){
+                if(st.isEmpty()){
+                    for(int j=i;j>=0;--j){ //删除不符合的')'  多种情况
+                        if(s.charAt(j)==')'){
+                            String s1=s.substring(0,j)+s.substring(j+1);
+                            if(!vis.contains(s1)){
+                                vis.add(s1);
+                                queue.offer(s1);
+                            }
+                        }
+                    }
+                    return false;
+                }else{
+                    st.pop();
+                }
+            }
+        }
+        if(st.isEmpty()){
+            ans.add(s);
+            return true;
+        }
+        return false;
+    }
+
+    public boolean checkRight(String s,List<String> ans){ //检查右边
+        //delete right
+        Stack<Character> st=new Stack<Character>();
+        st.clear();
+        for(int i=s.length()-1;i>=0;--i){
+            if(s.charAt(i)==')'){
+                st.push(s.charAt(i));
+            }else if(s.charAt(i)=='('){
+                if(st.isEmpty()){
+                    for(int j=i;j<s.length();++j){
+                        if(s.charAt(j)=='('){  //删除不符合的'(' 多种情况
+                            String s1=s.substring(0,j)+s.substring(j+1);
+                            if(!vis.contains(s1)){
+                                vis.add(s1);
+                                queue.add(s1);
+                            }
+                        }
+                    }
+                    return false;
+                }else{
+                    st.pop();
+                }
+            }
+        }
+        if(st.isEmpty()){
+            ans.add(s);
+            return true;
+        }
+        return false;
+    }
+}
+
+
+```
+
+
+
+
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/fz0rq.png)
\ No newline at end of file

LeetCode 第 326 号问题：3 的幂.md

+# LeetCode 第 326 号问题：3 的幂
+
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+
+题目来源于 LeetCode 上第 326 号问题：3 的幂。题目难度为 Easy，目前通过率为 43.5% 。
+
+### 题目描述
+
+给定一个整数，写一个函数来判断它是否是 3 的幂次方。
+
+**示例 1:**
+
+```
+输入: 27
+输出: true
+```
+
+**示例 2:**
+
+```
+输入: 0
+输出: false
+```
+
+**进阶：**
+你能不使用循环或者递归来完成本题吗？
+
+### 题目解析
+
+正常的思路是不停地去除以 3，看最后的迭代商是否为 1。这种思路的代码使用到了循环，逼格不够高。
+
+这里取巧的方法 **用到了数论的知识：3 的幂次的质因子只有 3**。
+
+题目要求输入的是 int 类型，正数范围是 0 - 2<sup>31</sup>，在此范围中允许的最大的 3 的次方数为 3<sup>19 </sup>= 1162261467 ，那么只要看这个数能否被 n 整除即可。
+
+### 动画描述
+
+待补充
+
+### 代码实现
+
+
+
+```java
+class Solution {
+    public boolean isPowerOfThree(int n) {
+         return n > 0 && 1162261467 % n == 0;
+    }
+}
+```
+
+
+
+
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/fz0rq.png)
\ No newline at end of file

LeetCode 第 328 号问题：奇偶链表.md

+# LeetCode 第 328 号问题：奇偶链表
+
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+
+题目来源于 LeetCode 上第 328 号问题：奇偶链表。题目难度为 Medium，目前通过率为 52.0% 。
+
+### 题目描述
+
+给定一个单链表，把所有的奇数节点和偶数节点分别排在一起。请注意，这里的奇数节点和偶数节点指的是节点编号的奇偶性，而不是节点的值的奇偶性。
+
+请尝试使用原地算法完成。你的算法的空间复杂度应为 O(1)，时间复杂度应为 O(nodes)，nodes 为节点总数。
+
+**示例 1:**
+
+```
+输入: 1->2->3->4->5->NULL
+输出: 1->3->5->2->4->NULL
+```
+
+**示例 2:**
+
+```
+输入: 2->1->3->5->6->4->7->NULL 
+输出: 2->3->6->7->1->5->4->NULL
+```
+
+**说明:**
+
+- 应当保持奇数节点和偶数节点的相对顺序。
+- 链表的第一个节点视为奇数节点，第二个节点视为偶数节点，以此类推。
+
+### 题目解析
+
+这道题给了我们一个链表，让我们分开奇偶节点，所有奇节点在前，偶节点在后。
+
+* 设定两个虚拟节点，`dummyHead1 `用来保存奇节点，`dummyHead2 `来保存偶节点；
+* 遍历整个原始链表，将奇节点放于`dummyHead1 `中，其余的放置在`dummyHead2 `中
+* 遍历结束后，将`dummyHead2 `插入到`dummyHead1 `后面
+
+### 动画描述
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/20181104142817.gif)
+
+### 代码实现
+
+```
+class Solution {
+public:
+    ListNode* oddEvenList(ListNode* head) {
+
+        if(head == NULL || head->next == NULL || head->next->next == NULL)
+            return head;
+
+        ListNode* dummyHead1 = new ListNode(-1);
+        ListNode* dummyHead2 = new ListNode(-1);
+        ListNode* p1 = dummyHead1;
+        ListNode* p2 = dummyHead2;
+        ListNode* p = head;
+        for(int i = 0; p; i ++)
+            if(i % 2 == 0){
+                p1->next = p;
+                p = p->next;
+                p1 = p1->next;
+                p1->next = NULL;
+            }
+            else{
+                p2->next = p;
+                p = p->next;
+                p2 = p2->next;
+                p2->next = NULL;
+            }
+
+        p1->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

LeetCode 第 344 号问题：反转字符串.md

+# LeetCode 第 344 号问题：反转字符串
+
+> 本文首发于公众号「五分钟学算法」，是[图解 LeetCode ](<https://github.com/MisterBooo/LeetCodeAnimation>)系列文章之一。
+>
+> 个人网站：[https://www.cxyxiaowu.com](https://www.cxyxiaowu.com)
+
+题目来源于 LeetCode 第 344 号问题：反转字符串。面试官最喜欢让你手写的一道算法题！
+
+### 题目描述
+
+编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 `char[]` 的形式给出。
+
+不要给另外的数组分配额外的空间，你必须**原地修改输入数组**、使用 O(1) 的额外空间解决这一问题。
+
+你可以假设数组中的所有字符都是 [ASCII](https://baike.baidu.com/item/ASCII) 码表中的可打印字符。
+
+**示例 1：**
+
+```
+输入：["h","e","l","l","o"]
+输出：["o","l","l","e","h"]
+```
+
+**示例 2：**
+
+```
+输入：["H","a","n","n","a","h"]
+输出：["h","a","n","n","a","H"]
+```
+
+### 
+
+### 题目解析
+
+这道题没什么难度，直接从两头往中间走，同时交换两边的字符。注意需要白板编程写出来即可，也注意千万别回答一句使用 reverse() 这种高级函数来解决。。。
+
+### 动画描述
+
+![](<https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/ariy2.gif>)
+
+### 代码实现
+
+```
+class Solution {
+public:
+    string reverseString(string s) {
+        int i = 0, j = s.size() - 1;
+        while (i < j){
+            swap(s[i],s[j]);
+            i++;
+            j--;
+        }
+        return s;
+    }
+};
+```
+
+
+
+
+
+![](https://bucket-1257126549.cos.ap-guangzhou.myqcloud.com/blog/fz0rq.png)
\ No newline at end of file