Merge remote-tracking branch 'origin/master'

Author: minghaha

README.md

@@ -12,10 +12,10 @@
 </a>
 
 <p align="center">
-  <a href="https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ"><img src="https://img.shields.io/badge/知识星球-代码随想录-blue" alt=""></a>
+  <a href="https://mp.weixin.qq.com/s/RsdcQ9umo09R6cfnwXZlrQ"><img src="https://img.shields.io/badge/PDF下载-代码随想录-blueviolet" alt=""></a>
   <a href="https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw"><img src="https://img.shields.io/badge/刷题-微信群-green" alt=""></a>
-  <a href="https://img-blog.csdnimg.cn/20201210231711160.png"><img src="https://img.shields.io/badge/公众号-代码随想录-brightgreen" alt=""></a>
   <a href="https://space.bilibili.com/525438321"><img src="https://img.shields.io/badge/B站-代码随想录-orange" alt=""></a>
+  <a href="https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ"><img src="https://img.shields.io/badge/知识星球-代码随想录-blue" alt=""></a>
 </p>
 
 # LeetCode 刷题攻略
@@ -112,14 +112,24 @@
 
 （持续更新中.....）
 
+## 备战秋招
+
+1. [选择方向的时候，我也迷茫了](https://mp.weixin.qq.com/s/ZCzFiAHZHLqHPLJQXNm75g)
+2. [刷题就用库函数了，怎么了？](https://mp.weixin.qq.com/s/6K3_OSaudnHGq2Ey8vqYfg)
+3. [关于实习，大家可能有点迷茫！](https://mp.weixin.qq.com/s/xcxzi7c78kQGjvZ8hh7taA)
+4. [马上秋招了，慌得很！](https://mp.weixin.qq.com/s/7q7W8Cb2-a5U5atZdOnOFA)
+5. [Carl看了上百份简历，总结了这些！](https://mp.weixin.qq.com/s/sJa87MZD28piCOVMFkIbwQ)
+6. [面试中遇到了发散性问题.....](https://mp.weixin.qq.com/s/SSonDxi2pjkSVwHNzZswng)
+
 ## 数组 
 
 1. [数组过于简单，但你该了解这些！](./problems/数组理论基础.md) 
 2. [数组：每次遇到二分法，都是一看就会，一写就废](./problems/0704.二分查找.md)
 3. [数组：就移除个元素很难么？](./problems/0027.移除元素.md)
-4. [数组：滑动窗口拯救了你](./problems/0209.长度最小的子数组.md)
-5. [数组：这个循环可以转懵很多人！](./problems/0059.螺旋矩阵II.md)
-6. [数组：总结篇](./problems/数组总结篇.md)
+4. [数组：有序数组的平方，还有序么？](./problems/0977.有序数组的平方.md)    
+5. [数组：滑动窗口拯救了你](./problems/0209.长度最小的子数组.md)
+6. [数组：这个循环可以转懵很多人！](./problems/0059.螺旋矩阵II.md)
+7. [数组：总结篇](./problems/数组总结篇.md)
 
 ## 链表
 
@@ -292,6 +302,7 @@
 
 动态规划专题已经开始啦，来不及解释了，小伙伴们上车别掉队！
 
+<img src='https://code-thinking.cdn.bcebos.com/pics/动态规划-总结大纲1.jpg' width=500> </img></div>
 1. [关于动态规划，你该了解这些！](./problems/动态规划理论基础.md)
 2. [动态规划：斐波那契数](./problems/0509.斐波那契数.md)
 3. [动态规划：爬楼梯](./problems/0070.爬楼梯.md)
@@ -366,6 +377,7 @@
 52. [为了绝杀编辑距离，Carl做了三步铺垫，你都知道么？](./problems/为了绝杀编辑距离，卡尔做了三步铺垫.md)
 53. [动态规划：回文子串](./problems/0647.回文子串.md)
 54. [动态规划：最长回文子序列](./problems/0516.最长回文子序列.md)
+55. [动态规划总结篇](./problems/动态规划总结篇.md)
 
 
 （持续更新中....）
@@ -390,12 +402,7 @@
 
 [各类基础算法模板](https://github.com/youngyangyang04/leetcode/blob/master/problems/算法模板.md)
 
-# 备战秋招
 
-1. [技术比较弱，也对技术不感兴趣，如何选择方向？](https://mp.weixin.qq.com/s/ZCzFiAHZHLqHPLJQXNm75g)
-2. [刷题就用库函数了，怎么了？](https://mp.weixin.qq.com/s/6K3_OSaudnHGq2Ey8vqYfg)
-3. [关于实习，大家可能有点迷茫！](https://mp.weixin.qq.com/s/xcxzi7c78kQGjvZ8hh7taA)
-4. [马上秋招了，慌得很！](https://mp.weixin.qq.com/s/7q7W8Cb2-a5U5atZdOnOFA)
 
 # B站算法视频讲解 
 

problems/0001.两数之和.md

@@ -29,17 +29,17 @@ https://leetcode-cn.com/problems/two-sum/
 很明显暴力的解法是两层for循环查找，时间复杂度是O(n^2)。
 
 建议大家做这道题目之前，先做一下这两道
-* [242. 有效的字母异位词](https://mp.weixin.qq.com/s/vM6OszkM6L1Mx2Ralm9Dig)
-* [349. 两个数组的交集](https://mp.weixin.qq.com/s/N9iqAchXreSVW7zXUS4BVA)
+* [242. 有效的字母异位词](https://mp.weixin.qq.com/s/ffS8jaVFNUWyfn_8T31IdA)
+* [349. 两个数组的交集](https://mp.weixin.qq.com/s/aMSA5zrp3jJcLjuSB0Es2Q)
 
-[242. 有效的字母异位词](https://mp.weixin.qq.com/s/vM6OszkM6L1Mx2Ralm9Dig) 这道题目是用数组作为哈希表来解决哈希问题，[349. 两个数组的交集](https://mp.weixin.qq.com/s/N9iqAchXreSVW7zXUS4BVA)这道题目是通过set作为哈希表来解决哈希问题。
+[242. 有效的字母异位词](https://mp.weixin.qq.com/s/ffS8jaVFNUWyfn_8T31IdA) 这道题目是用数组作为哈希表来解决哈希问题，[349. 两个数组的交集](https://mp.weixin.qq.com/s/aMSA5zrp3jJcLjuSB0Es2Q)这道题目是通过set作为哈希表来解决哈希问题。
 
 本题呢，则要使用map，那么来看一下使用数组和set来做哈希法的局限。
 
 * 数组的大小是受限制的，而且如果元素很少，而哈希值太大会造成内存空间的浪费。
-* set是一个集合，里面放的元素只能是一个key，而两数之和这道题目，不仅要判断y是否存在而且还要记录y的下标位置，因为要返回x 和 y的下标。所以set 也不能用。
+* set是一个集合，里面放的元素只能是一个key，而两数之和这道题目，不仅要判断y是否存在而且还要记录y的下表位置，因为要返回x 和 y的下表。所以set 也不能用。
 
-此时就要选择另一种数据结构：map ，map是一种key value的存储结构，可以用key保存数值，用value在保存数值所在的下标。
+此时就要选择另一种数据结构：map ，map是一种key value的存储结构，可以用key保存数值，用value在保存数值所在的下表。
 
 C++中map，有三种类型：
 
@@ -51,13 +51,12 @@ C++中map，有三种类型：
 
 std::unordered_map 底层实现为哈希表，std::map 和std::multimap 的底层实现是红黑树。
 
-同理，std::map 和std::multimap 的key也是有序的（这个问题也经常作为面试题，考察对语言容器底层的理解）。 更多哈希表的理论知识请看[关于哈希表，你该了解这些！](https://mp.weixin.qq.com/s/g8N6WmoQmsCUw3_BaWxHZA)。
+同理，std::map 和std::multimap 的key也是有序的（这个问题也经常作为面试题，考察对语言容器底层的理解）。 更多哈希表的理论知识请看[关于哈希表，你该了解这些！](https://mp.weixin.qq.com/s/RSUANESA_tkhKhYe3ZR8Jg)。
 
 **这道题目中并不需要key有序，选择std::unordered_map 效率更高！**
 
 解题思路动画如下：
 
-
 ![](https://code-thinking.cdn.bcebos.com/gifs/1.两数之和.gif)
 
 
@@ -136,6 +135,21 @@ func twoSum(nums []int, target int) []int {
 }
 ```
 
+```go
+// 使用map方式解题，降低时间复杂度
+func twoSum(nums []int, target int) []int {
+    m := make(map[int]int)
+    for index, val := range nums {
+        if preIndex, ok := m[target-val]; ok {
+            return []int{preIndex, index}
+        } else {
+            m[val] = index
+        }
+    }
+    return []int{}
+}
+```
+
 Rust
 
 ```rust

problems/0015.三数之和.md

@@ -105,8 +105,7 @@ public:
 
 时间复杂度：O(n^2)。
 
-
-## 双指针法C++代码
+C++代码代码如下：
 
 ```C++
 class Solution {
@@ -163,13 +162,14 @@ public:
 
 # 思考题
 
-既然三数之和可以使用双指针法，我们之前讲过的[两数之和](https://mp.weixin.qq.com/s/uVAtjOHSeqymV8FeQbliJQ)，可不可以使用双指针法呢？
+
+既然三数之和可以使用双指针法，我们之前讲过的[1.两数之和](https://mp.weixin.qq.com/s/vaMsLnH-f7_9nEK4Cuu3KQ)，可不可以使用双指针法呢？
 
 如果不能，题意如何更改就可以使用双指针法呢？  **大家留言说出自己的想法吧！**
 
-两数之和 就不能使用双指针法，因为[两数之和](https://mp.weixin.qq.com/s/uVAtjOHSeqymV8FeQbliJQ)要求返回的是索引下表， 而双指针法一定要排序，一旦排序之后原数组的索引就被改变了。
+两数之和 就不能使用双指针法，因为[1.两数之和](https://mp.weixin.qq.com/s/vaMsLnH-f7_9nEK4Cuu3KQ)要求返回的是索引下表， 而双指针法一定要排序，一旦排序之后原数组的索引就被改变了。
 
-如果[两数之和](https://mp.weixin.qq.com/s/uVAtjOHSeqymV8FeQbliJQ)要求返回的是数值的话，就可以使用双指针法了。
+如果[1.两数之和](https://mp.weixin.qq.com/s/vaMsLnH-f7_9nEK4Cuu3KQ)要求返回的是数值的话，就可以使用双指针法了。
 
 
 
@@ -336,6 +336,23 @@ var threeSum = function(nums) {
 ```
 
 
+ruby:
+```ruby
+def is_valid(strs)
+    symbol_map = {')' => '(', '}' => '{', ']' => '['}
+    stack = []
+    strs.size.times {|i|
+        c = strs[i]
+        if symbol_map.has_key?(c)
+            top_e = stack.shift
+            return false if symbol_map[c] != top_e
+        else
+            stack.unshift(c)
+        end
+    }
+    stack.empty?
+end
+```
 
 -----------------------
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)

problems/0017.电话号码的字母组合.md

@@ -137,7 +137,7 @@ for (int i = 0; i < letters.size(); i++) {
 关键地方都讲完了，按照[关于回溯算法，你该了解这些！](https://mp.weixin.qq.com/s/gjSgJbNbd1eAA5WkA-HeWw)中的回溯法模板，不难写出如下C++代码：
 
 
-```
+```c++
 // 版本一
 class Solution {
 private:
@@ -183,7 +183,7 @@ public:
 
 一些写法，是把回溯的过程放在递归函数里了，例如如下代码，我可以写成这样：（注意注释中不一样的地方）
 
-```
+```c++
 // 版本二
 class Solution {
 private:
@@ -319,7 +319,7 @@ class Solution:
 
 python3：
 
-```python3
+```py
 class Solution:
     def letterCombinations(self, digits: str) -> List[str]:
         self.s = ""
@@ -342,6 +342,33 @@ class Solution:
 
 Go：
 
+javaScript：
+
+```js
+var letterCombinations = function(digits) {
+    const k = digits.length;
+    const map = ["","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"];
+    if(!k) return [];
+    if(k === 1) return map[digits].split("");
+
+    const res = [], path = [];
+    backtracking(digits, k, 0);
+    return res;
+
+    function backtracking(n, k, a) {
+        if(path.length === k) {
+            res.push(path.join(""));
+            return;
+        }
+        for(const v of map[n[a]]) {
+            path.push(v);
+            backtracking(n, k, a + 1);
+            path.pop();
+        }
+
+    }
+};
+```
 
 
 

problems/0018.四数之和.md

@@ -31,38 +31,39 @@ https://leetcode-cn.com/problems/4sum/
 
 # 思路
 
-四数之和，和[三数之和](https://mp.weixin.qq.com/s/r5cgZFu0tv4grBAexdcd8A)是一个思路，都是使用双指针法, 基本解法就是在[三数之和](https://mp.weixin.qq.com/s/r5cgZFu0tv4grBAexdcd8A) 的基础上再套一层for循环。
+四数之和，和[15.三数之和](https://mp.weixin.qq.com/s/QfTNEByq1YlNSXRKEumwHg)是一个思路，都是使用双指针法, 基本解法就是在[15.三数之和](https://mp.weixin.qq.com/s/QfTNEByq1YlNSXRKEumwHg) 的基础上再套一层for循环。
 
 但是有一些细节需要注意，例如： 不要判断`nums[k] > target` 就返回了，三数之和 可以通过 `nums[i] > 0` 就返回了，因为 0 已经是确定的数了，四数之和这道题目 target是任意值。（大家亲自写代码就能感受出来）
 
-[三数之和](https://mp.weixin.qq.com/s/r5cgZFu0tv4grBAexdcd8A)的双指针解法是一层for循环num[i]为确定值，然后循环内有left和right下表作为双指针，找到nums[i] + nums[left] + nums[right] == 0。
+[15.三数之和](https://mp.weixin.qq.com/s/QfTNEByq1YlNSXRKEumwHg)的双指针解法是一层for循环num[i]为确定值，然后循环内有left和right下表作为双指针，找到nums[i] + nums[left] + nums[right] == 0。
 
 四数之和的双指针解法是两层for循环nums[k] + nums[i]为确定值，依然是循环内有left和right下表作为双指针，找出nums[k] + nums[i] + nums[left] + nums[right] == target的情况，三数之和的时间复杂度是O(n^2)，四数之和的时间复杂度是O(n^3) 。
 
 那么一样的道理，五数之和、六数之和等等都采用这种解法。
 
-对于[三数之和](https://mp.weixin.qq.com/s/r5cgZFu0tv4grBAexdcd8A)双指针法就是将原本暴力O(n^3)的解法，降为O(n^2)的解法，四数之和的双指针解法就是将原本暴力O(n^4)的解法，降为O(n^3)的解法。
+对于[15.三数之和](https://mp.weixin.qq.com/s/QfTNEByq1YlNSXRKEumwHg)双指针法就是将原本暴力O(n^3)的解法，降为O(n^2)的解法，四数之和的双指针解法就是将原本暴力O(n^4)的解法，降为O(n^3)的解法。
 
-之前我们讲过哈希表的经典题目：[四数相加II](https://mp.weixin.qq.com/s/Ue8pKKU5hw_m-jPgwlHcbA)，相对于本题简单很多，因为本题是要求在一个集合中找出四个数相加等于target，同时四元组不能重复。
+之前我们讲过哈希表的经典题目：[454.四数相加II](https://mp.weixin.qq.com/s/12g_w6RzHuEpFts1pT6BWw)，相对于本题简单很多，因为本题是要求在一个集合中找出四个数相加等于target，同时四元组不能重复。
 
-而[四数相加II](https://mp.weixin.qq.com/s/Ue8pKKU5hw_m-jPgwlHcbA)是四个独立的数组，只要找到A[i] + B[j] + C[k] + D[l] = 0就可以，不用考虑有重复的四个元素相加等于0的情况，所以相对于本题还是简单了不少！
+而[454.四数相加II](https://mp.weixin.qq.com/s/12g_w6RzHuEpFts1pT6BWw)是四个独立的数组，只要找到A[i] + B[j] + C[k] + D[l] = 0就可以，不用考虑有重复的四个元素相加等于0的情况，所以相对于本题还是简单了不少！
 
 我们来回顾一下，几道题目使用了双指针法。
 
 双指针法将时间复杂度O(n^2)的解法优化为 O(n)的解法。也就是降一个数量级，题目如下：
-* [0027.移除元素](https://mp.weixin.qq.com/s/wj0T-Xs88_FHJFwayElQlA)
-* [15.三数之和](https://mp.weixin.qq.com/s/r5cgZFu0tv4grBAexdcd8A)
-* [18.四数之和](https://mp.weixin.qq.com/s/nQrcco8AZJV1pAOVjeIU_g)
 
-双指针来记录前后指针实现链表反转：
+* [27.移除元素](https://mp.weixin.qq.com/s/RMkulE4NIb6XsSX83ra-Ww)
+* [15.三数之和](https://mp.weixin.qq.com/s/QfTNEByq1YlNSXRKEumwHg)
+* [18.四数之和](https://mp.weixin.qq.com/s/nQrcco8AZJV1pAOVjeIU_g)
 
-* [206.反转链表](https://mp.weixin.qq.com/s/pnvVP-0ZM7epB8y3w_Njwg)
 
-使用双指针来确定有环：
+操作链表：
 
-* [142题.环形链表II](https://mp.weixin.qq.com/s/_QVP3IkRZWx9zIpQRgajzA)
+* [206.反转链表](https://mp.weixin.qq.com/s/ckEvIVGcNLfrz6OLOMoT0A)
+* [19.删除链表的倒数第N个节点](https://mp.weixin.qq.com/s/gxu65X1343xW_sBrkTz0Eg)
+* [面试题 02.07. 链表相交](https://mp.weixin.qq.com/s/BhfFfaGvt9Zs7UmH4YehZw)
+* [142题.环形链表II](https://mp.weixin.qq.com/s/gt_VH3hQTqNxyWcl1ECSbQ)
 
-双指针法在数组和链表中还有很多应用，后面还会介绍到。
+双指针法在字符串题目中还有很多应用，后面还会介绍到。
 
 C++代码
 

problems/0019.删除链表的倒数第N个节点.md

@@ -112,6 +112,30 @@ class Solution {
     }
 }
 ```
+
+Python:
+```python
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
+        head_dummy = ListNode()
+        head_dummy.next = head
+
+        slow, fast = head_dummy, head_dummy
+        while(n!=0): #fast先往前走n步
+            fast = fast.next
+            n -= 1
+        while(fast.next!=None):
+            slow = slow.next
+            fast = fast.next
+        #fast 走到结尾后，slow的下一个节点为倒数第N个节点
+        slow.next = slow.next.next #删除
+        return head_dummy.next
+```
 Go:
 ```Go
 /**

problems/0024.两两交换链表中的节点.md

@@ -129,6 +129,23 @@ class Solution {
 ```
 
 Python：
+```python
+class Solution:
+    def swapPairs(self, head: ListNode) -> ListNode:
+        dummy = ListNode(0) #设置一个虚拟头结点
+        dummy.next = head
+        cur = dummy
+        while cur.next and cur.next.next: 
+            tmp = cur.next #记录临时节点
+            tmp1 = cur.next.next.next #记录临时节点
+            
+            cur.next = cur.next.next          #步骤一
+            cur.next.next = tmp               #步骤二
+            cur.next.next.next = tmp1         #步骤三
+            
+            cur = cur.next.next #cur移动两位，准备下一轮交换
+        return dummy.next
+```
 
 Go：
 ```go

problems/0027.移除元素.md

@@ -186,6 +186,36 @@ var removeElement = (nums, val) => {
 };
 ```
 
+Ruby:
+```ruby
+def remove_element(nums, val)
+    i = 0
+    nums.each_index do |j| 
+        if nums[j] != val
+            nums[i] = nums[j]
+            i+=1
+        end
+    end
+    i
+end
+```
+Rust:
+```rust
+pub fn remove_element(nums: &mut Vec<i32>, val: i32) -> &mut Vec<i32> {
+    let mut start: usize = 0;
+    while start < nums.len() {
+        if nums[start] == val {
+            nums.remove(start);
+        }
+        start += 1;
+    }
+    nums
+}
+fn main() {
+    let mut nums = vec![5,1,3,5,2,3,4,1];
+    println!("{:?}",remove_element(&mut nums, 5));
+}
+```
 -----------------------
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)