Update

Author: youngyangyang04

README.md

@@ -281,6 +281,7 @@
 |[0131.分割回文串](https://github.com/youngyangyang04/leetcode/blob/master/problems/0131.分割回文串.md) |回溯 |中等|**回溯**|
 |[0141.环形链表](https://github.com/youngyangyang04/leetcode/blob/master/problems/0141.环形链表.md) |链表 |简单|**快慢指针/双指针**|
 |[0142.环形链表II](https://github.com/youngyangyang04/leetcode/blob/master/problems/0142.环形链表II.md) |链表 |中等|**快慢指针/双指针**|
+|[0143.重排链表](https://github.com/youngyangyang04/leetcode/blob/master/problems/0143.重排链表.md) |链表 |中等|**快慢指针/双指针** 也可以用数组，双向队列模拟，考察链表综合操作的好题|
 |[0144.二叉树的前序遍历](https://github.com/youngyangyang04/leetcode/blob/master/problems/0144.二叉树的前序遍历.md) |树 |中等|**递归** **迭代/栈**|
 |[0145.二叉树的后序遍历](https://github.com/youngyangyang04/leetcode/blob/master/problems/0145.二叉树的后序遍历.md) |树 |困难|**递归** **迭代/栈**|
 |[0151.翻转字符串里的单词](https://github.com/youngyangyang04/leetcode/blob/master/problems/0151.翻转字符串里的单词.md) |字符串 |中等|**模拟/双指针**|
@@ -339,6 +340,7 @@
 |[0705.设计哈希集合](https://github.com/youngyangyang04/leetcode/blob/master/problems/0705.设计哈希集合.md) |哈希表 |简单|**模拟**|
 |[0707.设计链表](https://github.com/youngyangyang04/leetcode/blob/master/problems/0707.设计链表.md) |链表 |中等|**模拟**|
 |[0841.钥匙和房间](https://github.com/youngyangyang04/leetcode/blob/master/problems/0841.钥匙和房间.md) |孤岛问题 |中等|**bfs** **dfs**|
+|[0844.比较含退格的字符串](https://github.com/youngyangyang04/leetcode/blob/master/problems/0844.比较含退格的字符串.md) |字符串 |简单|**栈** **双指针优化** 使用栈的思路但没有必要使用栈|
 |[0977.有序数组的平方](https://github.com/youngyangyang04/leetcode/blob/master/problems/0977.有序数组的平方.md) |数组 |中等|**双指针**|
 |[1002.查找常用字符](https://github.com/youngyangyang04/leetcode/blob/master/problems/1002.查找常用字符.md) |栈 |简单|**栈**|
 |[1047.删除字符串中的所有相邻重复项](https://github.com/youngyangyang04/leetcode/blob/master/problems/1047.删除字符串中的所有相邻重复项.md) |哈希表 |简单|**哈希表/数组**|

pics/143.重排链表.png

@@ -170,7 +170,13 @@ public:
 
 那么本题使用单调栈有如下几个问题：
 
-1. 使用单调栈内元素的顺序
+1. 首先单调栈是按照行方向来计算雨水，如图：
+
+<img src='../pics/42.接雨水2.png' width=600> </img></div>
+
+知道这一点，后面的就可以理解了。
+
+2. 使用单调栈内元素的顺序
 
 从大到小还是从小打到呢？
 
@@ -183,7 +189,7 @@ public:
 <img src='../pics/42.接雨水4.png' width=600> </img></div>
 
 
-2. 遇到相同高度的柱子怎么办。 
+3. 遇到相同高度的柱子怎么办。 
 
 遇到相同的元素，更新栈内下表，就是将栈里元素（旧下标）弹出，将新元素（新下标）加入栈中。
 
@@ -197,7 +203,7 @@ public:
 <img src='../pics/42.接雨水5.png' width=600> </img></div>
 
 
-3. 栈里要保存什么数值
+4. 栈里要保存什么数值
 
 是用单调栈，其实是通过 长 * 宽 来计算雨水面积的。
 

problems/0042.接雨水.md

@@ -0,0 +1,31 @@
+
+# 链接 
+
+https://leetcode-cn.com/problems/largest-rectangle-in-histogram/ 
+
+## 思路
+
+```
+class Solution {
+public:
+    int largestRectangleArea(vector<int>& heights) {
+        int sum = 0;
+        for (int i = 0; i < heights.size(); i++) {
+            int left = i;
+            int right = i;
+            for (; left >= 0; left--) {
+                if (heights[left] < heights[i]) break;
+            }
+            for (; right < heights.size(); right++) {
+                if (heights[right] < heights[i]) break;
+            }
+            int w = right - left - 1;
+            int h = heights[i];
+            sum = max(sum, w * h);
+        }
+        return sum;
+    }
+};
+```
+
+如上代码并不能通过leetcode，超时了，因为时间复杂度是O(n^2)。

problems/0084.柱状图中最大的矩形.md

@@ -0,0 +1,160 @@
+
+# 思路 
+
+本篇将给出三种C++实现的方法 
+
+* 数组模拟 
+* 双向队列模拟 
+* 直接分割链表
+
+## 方法一
+
+把链表放进数组中，然后通过双指针法，一前一后，来遍历数组，构造链表。 
+
+代码如下：
+
+```
+class Solution {
+public:
+    void reorderList(ListNode* head) {
+        vector<ListNode*> vec;
+        ListNode* cur = head;
+        if (cur == nullptr) return;
+        while(cur != nullptr) {
+            vec.push_back(cur);
+            cur = cur->next;
+        }
+        cur = head;
+        int i = 1;
+        int j = vec.size() - 1;
+        int count = 0; // 计数，用来取前面，取后面
+        while (i <= j) {
+            if (count % 2 == 0) {
+                cur->next = vec[j];
+                j--;
+            } else {
+                cur->next = vec[i];
+                i++;
+            }
+            cur = cur->next;
+            count++;
+        }
+        if (vec.size() % 2 == 0) {
+            cur->next = vec[i];
+            cur = cur->next;
+        }
+        cur->next = nullptr; // 注意结尾
+    }
+};
+```
+
+## 方法二 
+
+把链表放进双向队列，然后通过双向队列一前一后弹出数据，来构造新的链表。这种方法比操作数组容易一些，不用双指针模拟一前一后了
+```
+class Solution {
+public:
+    void reorderList(ListNode* head) {
+        deque<ListNode*> que;
+        ListNode* cur = head;
+        if (cur == nullptr) return;
+
+        while(cur->next != nullptr) {
+            que.push_back(cur->next);
+            cur = cur->next;
+        }
+
+        cur = head;
+        int count = 0;
+        ListNode* node;
+        while(que.size()) {
+            if (count % 2 == 0) {
+                node = que.back();
+                que.pop_back();
+            } else {
+                node = que.front();
+                que.pop_front();
+            }
+            count++;
+            cur->next = node;
+            cur = cur->next;
+        }
+        cur->next = nullptr;
+    }
+};
+```
+
+## 方法三 
+
+将链表分割成两个链表，然后把第二个链表反转，之后在通过两个链表拼接成新的链表。
+
+如图：
+
+<img src='../pics/143.重排链表.png' width=600> </img></div>
+
+这种方法，比较难，平均切割链表，看上去很简单，真正代码写的时候有很多细节，同时两个链表最后拼装整一个新的链表也有一些细节需要注意！
+
+代码如下：
+
+```
+class Solution {
+private:
+    ListNode* reverseList(ListNode* head) {
+        ListNode* temp; // 保存cur的下一个节点
+        ListNode* cur = head;
+        ListNode* pre = NULL;
+        while(cur) {
+            temp = cur->next;  // 保存一下 cur的下一个节点，因为接下来要改变cur->next
+            cur->next = pre; // 翻转操作
+            // 更新pre 和 cur指针
+            pre = cur;
+            cur = temp;
+        }
+        return pre;
+    }
+
+public:
+    void reorderList(ListNode* head) {
+        if (head == nullptr) return;
+        // 使用快慢指针法，将链表分成长度均等的两个链表head1和head2
+        // 如果总链表长度为奇数，则head1相对head2多一个节点
+        ListNode* fast = head;
+        ListNode* slow = head;
+        while (fast && fast->next && fast->next->next) {
+            fast = fast->next->next;
+            slow = slow->next;
+        }
+        ListNode* head1 = head;
+        ListNode* head2;
+        head2 = slow->next;
+        slow->next = nullptr;
+
+        // 对head2进行翻转
+        head2 = reverseList(head2);
+
+        // 将head1和head2交替生成新的链表head
+        ListNode* cur1 = head1;
+        ListNode* cur2 = head2;
+        ListNode* cur = head;
+        cur1 = cur1->next;
+        int count = 0;
+        while (cur1 && cur2) {
+            if (count % 2 == 0) {
+                cur->next = cur2;
+                cur2 = cur2->next;
+            } else {
+                cur->next = cur1;
+                cur1 = cur1->next;
+            }
+            count++;
+            cur = cur->next;
+        }
+        if (cur2 != nullptr) {
+            cur->next = cur2;
+        }
+        if (cur1 != nullptr) {
+            cur->next = cur1;
+        }
+    }
+};
+```

problems/0143.重排链表.md

@@ -30,6 +30,22 @@ public:
 };
 ```
 
+代码精简之后
+
+```
+class Solution {
+public:
+    bool containsNearbyDuplicate(vector<int>& nums, int k) {
+        unordered_map<int, int> map;
+        for (int i = 0; i < nums.size(); i++) {
+            if (map.find(nums[i]) != map.end() && i - map[nums[i]] <= k) return true;
+            map[nums[i]] = i;
+        }
+        return false;
+    }
+};
+```
+
 
 > 更过算法干货文章持续更新，可以微信搜索「代码随想录」第一时间围观，关注后，回复「Java」「C++」 「python」「简历模板」「数据结构与算法」等等，就可以获得我多年整理的学习资料。
 

problems/0219.存在重复元素II.md

@@ -21,7 +21,7 @@ https://leetcode-cn.com/problems/count-complete-tree-nodes/
 
 依然可以使用递归法和迭代法来解决。
 
-这道题目的递归法和求二叉树的深度写法类似， 而迭代法：二叉树层序遍历模板稍稍修改一下，记录遍历的节点数量就可以了。
+这道题目的递归法和求二叉树的深度写法类似， 而迭代法，[二叉树：层序遍历登场！](https://mp.weixin.qq.com/s/Gb3BjakIKGNpup2jYtTzog)遍历模板稍稍修改一下，记录遍历的节点数量就可以了。
 
 递归遍历的顺序依然是后序（左右中）。