Merge branch 'youngyangyang04:master' into master

Author: hailincai

problems/0005.最长回文子串.md

@@ -10,7 +10,7 @@
 
 # 5.最长回文子串
 
-题目链接：https://leetcode-cn.com/problems/longest-palindromic-substring/
+[力扣题目链接](https://leetcode-cn.com/problems/longest-palindromic-substring/)
 
 给你一个字符串 s，找到 s 中最长的回文子串。
 
@@ -30,11 +30,11 @@
 示例 4：
 * 输入：s = "ac"
 * 输出："a"
- 
+
 
 # 思路
 
-本题和[647.回文子串](https://mp.weixin.qq.com/s/2WetyP6IYQ6VotegepVpEw) 差不多是一样的，但647.回文子串更基本一点，建议可以先做647.回文子串
+本题和[647.回文子串](https://programmercarl.com/0647.回文子串.html) 差不多是一样的，但647.回文子串更基本一点，建议可以先做647.回文子串
 
 ## 暴力解法
 

problems/0015.三数之和.md

@@ -8,11 +8,11 @@
 
 
 
-> 用哈希表解决了[两数之和](https://mp.weixin.qq.com/s/uVAtjOHSeqymV8FeQbliJQ)，那么三数之和呢？
+> 用哈希表解决了[两数之和](https://programmercarl.com/0001.两数之和.html)，那么三数之和呢？
 
 # 第15题. 三数之和
 
-https://leetcode-cn.com/problems/3sum/
+[力扣题目链接](https://leetcode-cn.com/problems/3sum/)
 
 给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。
 
@@ -37,7 +37,7 @@ https://leetcode-cn.com/problems/3sum/
 
 两层for循环就可以确定 a 和b 的数值了，可以使用哈希法来确定 0-(a+b) 是否在 数组里出现过，其实这个思路是正确的，但是我们有一个非常棘手的问题，就是题目中说的不可以包含重复的三元组。
 
-把符合条件的三元组放进vector中，然后在去去重，这样是非常费时的，很容易超时，也是这道题目通过率如此之低的根源所在。
+把符合条件的三元组放进vector中，然后再去重，这样是非常费时的，很容易超时，也是这道题目通过率如此之低的根源所在。
 
 去重的过程不好处理，有很多小细节，如果在面试中很难想到位。
 
@@ -95,11 +95,11 @@ public:
 
 ![15.三数之和](https://code-thinking.cdn.bcebos.com/gifs/15.%E4%B8%89%E6%95%B0%E4%B9%8B%E5%92%8C.gif)
 
-拿这个nums数组来举例，首先将数组排序，然后有一层for循环，i从下表0的地方开始，同时定一个下表left 定义在i+1的位置上，定义下表right 在数组结尾的位置上。
+拿这个nums数组来举例，首先将数组排序，然后有一层for循环，i从下标0的地方开始，同时定一个下标left 定义在i+1的位置上，定义下标right 在数组结尾的位置上。
 
 依然还是在数组中找到 abc 使得a + b +c =0，我们这里相当于  a = nums[i] b = nums[left]  c = nums[right]。
 
-接下来如何移动left 和right呢， 如果nums[i] + nums[left] + nums[right] > 0  就说明 此时三数之和大了，因为数组是排序后了，所以right下表就应该向左移动，这样才能让三数之和小一些。
+接下来如何移动left 和right呢， 如果nums[i] + nums[left] + nums[right] > 0  就说明 此时三数之和大了，因为数组是排序后了，所以right下标就应该向左移动，这样才能让三数之和小一些。
 
 如果 nums[i] + nums[left] + nums[right] < 0 说明 此时 三数之和小了，left 就向右移动，才能让三数之和大一些，直到left与right相遇为止。
 
@@ -163,13 +163,13 @@ public:
 # 思考题
 
 
-既然三数之和可以使用双指针法，我们之前讲过的[1.两数之和](https://mp.weixin.qq.com/s/vaMsLnH-f7_9nEK4Cuu3KQ)，可不可以使用双指针法呢？
+既然三数之和可以使用双指针法，我们之前讲过的[1.两数之和](https://programmercarl.com/0001.两数之和.html)，可不可以使用双指针法呢？
 
 如果不能，题意如何更改就可以使用双指针法呢？  **大家留言说出自己的想法吧！**
 
-两数之和 就不能使用双指针法，因为[1.两数之和](https://mp.weixin.qq.com/s/vaMsLnH-f7_9nEK4Cuu3KQ)要求返回的是索引下表， 而双指针法一定要排序，一旦排序之后原数组的索引就被改变了。
+两数之和 就不能使用双指针法，因为[1.两数之和](https://programmercarl.com/0001.两数之和.html)要求返回的是索引下标， 而双指针法一定要排序，一旦排序之后原数组的索引就被改变了。
 
-如果[1.两数之和](https://mp.weixin.qq.com/s/vaMsLnH-f7_9nEK4Cuu3KQ)要求返回的是数值的话，就可以使用双指针法了。
+如果[1.两数之和](https://programmercarl.com/0001.两数之和.html)要求返回的是数值的话，就可以使用双指针法了。
 
 
 

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

@@ -9,7 +9,7 @@
 
 # 17.电话号码的字母组合
 
-题目链接：https://leetcode-cn.com/problems/letter-combinations-of-a-phone-number/
+[力扣题目链接](https://leetcode-cn.com/problems/letter-combinations-of-a-phone-number/)
 
 给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。
 
@@ -29,7 +29,7 @@
 
 如果输入"233"呢，那么就三层for循环，如果"2333"呢，就四层for循环.......
 
-大家应该感觉出和[回溯算法：求组合问题！](https://mp.weixin.qq.com/s/OnBjbLzuipWz_u4QfmgcqQ)遇到的一样的问题，就是这for循环的层数如何写出来，此时又是回溯法登场的时候了。
+大家应该感觉出和[回溯算法：求组合问题！](https://programmercarl.com/0077.组合.html)遇到的一样的问题，就是这for循环的层数如何写出来，此时又是回溯法登场的时候了。
 
 理解本题后，要解决如下三个问题：
 
@@ -58,7 +58,7 @@ const string letterMap[10] = {
 
 ## 回溯法来解决n个for循环的问题
 
-对于回溯法还不了解的同学看这篇：[关于回溯算法，你该了解这些！](https://mp.weixin.qq.com/s/gjSgJbNbd1eAA5WkA-HeWw)
+对于回溯法还不了解的同学看这篇：[关于回溯算法，你该了解这些！](https://programmercarl.com/回溯算法理论基础.html)
 
 
 例如：输入："23"，抽象为树形结构，如图所示：
@@ -75,7 +75,7 @@ const string letterMap[10] = {
 
 再来看参数，参数指定是有题目中给的string digits，然后还要有一个参数就是int型的index。
 
-注意这个index可不是 [回溯算法：求组合问题！](https://mp.weixin.qq.com/s/OnBjbLzuipWz_u4QfmgcqQ)和[回溯算法：求组合总和！](https://mp.weixin.qq.com/s/HX7WW6ixbFZJASkRnCTC3w)中的startIndex了。
+注意这个index可不是 [回溯算法：求组合问题！](https://programmercarl.com/0077.组合.html)和[回溯算法：求组合总和！](https://programmercarl.com/0216.组合总和III.html)中的startIndex了。
 
 这个index是记录遍历第几个数字了，就是用来遍历digits的（题目中给出数字字符串），同时index也表示树的深度。
 
@@ -120,9 +120,9 @@ for (int i = 0; i < letters.size(); i++) {
 }
 ```
 
-**注意这里for循环，可不像是在[回溯算法：求组合问题！](https://mp.weixin.qq.com/s/OnBjbLzuipWz_u4QfmgcqQ)和[回溯算法：求组合总和！](https://mp.weixin.qq.com/s/HX7WW6ixbFZJASkRnCTC3w)中从startIndex开始遍历的**。
+**注意这里for循环，可不像是在[回溯算法：求组合问题！](https://programmercarl.com/0077.组合.html)和[回溯算法：求组合总和！](https://programmercarl.com/0216.组合总和III.html)中从startIndex开始遍历的**。
 
-**因为本题每一个数字代表的是不同集合，也就是求不同集合之间的组合，而[77. 组合](https://mp.weixin.qq.com/s/OnBjbLzuipWz_u4QfmgcqQ)和[216.组合总和III](https://mp.weixin.qq.com/s/HX7WW6ixbFZJASkRnCTC3w)都是是求同一个集合中的组合！**
+**因为本题每一个数字代表的是不同集合，也就是求不同集合之间的组合，而[77. 组合](https://programmercarl.com/0077.组合.html)和[216.组合总和III](https://programmercarl.com/0216.组合总和III.html)都是是求同一个集合中的组合！**
 
 
 注意：输入1 * #按键等等异常情况
@@ -134,7 +134,7 @@ for (int i = 0; i < letters.size(); i++) {
 
 ## C++代码
 
-关键地方都讲完了，按照[关于回溯算法，你该了解这些！](https://mp.weixin.qq.com/s/gjSgJbNbd1eAA5WkA-HeWw)中的回溯法模板，不难写出如下C++代码：
+关键地方都讲完了，按照[关于回溯算法，你该了解这些！](https://programmercarl.com/回溯算法理论基础.html)中的回溯法模板，不难写出如下C++代码：
 
 
 ```c++
@@ -224,13 +224,13 @@ public:
 };
 ```
 
-我不建议把回溯藏在递归的参数里这种写法，很不直观，我在[二叉树：以为使用了递归，其实还隐藏着回溯](https://mp.weixin.qq.com/s/ivLkHzWdhjQQD1rQWe6zWA)这篇文章中也深度分析了，回溯隐藏在了哪里。
+我不建议把回溯藏在递归的参数里这种写法，很不直观，我在[二叉树：以为使用了递归，其实还隐藏着回溯](https://programmercarl.com/二叉树中递归带着回溯.html)这篇文章中也深度分析了，回溯隐藏在了哪里。
 
 所以大家可以按照版本一来写就可以了。
 
 # 总结
 
-本篇将题目的三个要点一一列出，并重点强调了和前面讲解过的[77. 组合](https://mp.weixin.qq.com/s/OnBjbLzuipWz_u4QfmgcqQ)和[216.组合总和III](https://mp.weixin.qq.com/s/HX7WW6ixbFZJASkRnCTC3w)的区别，本题是多个集合求组合，所以在回溯的搜索过程中，都有一些细节需要注意的。
+本篇将题目的三个要点一一列出，并重点强调了和前面讲解过的[77. 组合](https://programmercarl.com/0077.组合.html)和[216.组合总和III](https://programmercarl.com/0216.组合总和III.html)的区别，本题是多个集合求组合，所以在回溯的搜索过程中，都有一些细节需要注意的。
 
 其实本题不算难，但也处处是细节，大家还要自己亲自动手写一写。
 

problems/0018.四数之和.md

@@ -12,7 +12,7 @@
 
 # 第18题. 四数之和
 
-https://leetcode-cn.com/problems/4sum/
+[力扣题目链接](https://leetcode-cn.com/problems/4sum/)
 
 题意：给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。
 
@@ -31,37 +31,37 @@ https://leetcode-cn.com/problems/4sum/
 
 # 思路
 
-四数之和，和[15.三数之和](https://mp.weixin.qq.com/s/QfTNEByq1YlNSXRKEumwHg)是一个思路，都是使用双指针法, 基本解法就是在[15.三数之和](https://mp.weixin.qq.com/s/QfTNEByq1YlNSXRKEumwHg) 的基础上再套一层for循环。
+四数之和，和[15.三数之和](https://programmercarl.com/0015.三数之和.html)是一个思路，都是使用双指针法, 基本解法就是在[15.三数之和](https://programmercarl.com/0015.三数之和.html) 的基础上再套一层for循环。
 
 但是有一些细节需要注意，例如： 不要判断`nums[k] > target` 就返回了，三数之和 可以通过 `nums[i] > 0` 就返回了，因为 0 已经是确定的数了，四数之和这道题目 target是任意值。（大家亲自写代码就能感受出来）
 
-[15.三数之和](https://mp.weixin.qq.com/s/QfTNEByq1YlNSXRKEumwHg)的双指针解法是一层for循环num[i]为确定值，然后循环内有left和right下表作为双指针，找到nums[i] + nums[left] + nums[right] == 0。
+[15.三数之和](https://programmercarl.com/0015.三数之和.html)的双指针解法是一层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) 。
 
 那么一样的道理，五数之和、六数之和等等都采用这种解法。
 
-对于[15.三数之和](https://mp.weixin.qq.com/s/QfTNEByq1YlNSXRKEumwHg)双指针法就是将原本暴力O(n^3)的解法，降为O(n^2)的解法，四数之和的双指针解法就是将原本暴力O(n^4)的解法，降为O(n^3)的解法。
+对于[15.三数之和](https://programmercarl.com/0015.三数之和.html)双指针法就是将原本暴力O(n^3)的解法，降为O(n^2)的解法，四数之和的双指针解法就是将原本暴力O(n^4)的解法，降为O(n^3)的解法。
 
-之前我们讲过哈希表的经典题目：[454.四数相加II](https://mp.weixin.qq.com/s/12g_w6RzHuEpFts1pT6BWw)，相对于本题简单很多，因为本题是要求在一个集合中找出四个数相加等于target，同时四元组不能重复。
+之前我们讲过哈希表的经典题目：[454.四数相加II](https://programmercarl.com/0454.四数相加II.html)，相对于本题简单很多，因为本题是要求在一个集合中找出四个数相加等于target，同时四元组不能重复。
 
-而[454.四数相加II](https://mp.weixin.qq.com/s/12g_w6RzHuEpFts1pT6BWw)是四个独立的数组，只要找到A[i] + B[j] + C[k] + D[l] = 0就可以，不用考虑有重复的四个元素相加等于0的情况，所以相对于本题还是简单了不少！
+而[454.四数相加II](https://programmercarl.com/0454.四数相加II.html)是四个独立的数组，只要找到A[i] + B[j] + C[k] + D[l] = 0就可以，不用考虑有重复的四个元素相加等于0的情况，所以相对于本题还是简单了不少！
 
 我们来回顾一下，几道题目使用了双指针法。
 
 双指针法将时间复杂度O(n^2)的解法优化为 O(n)的解法。也就是降一个数量级，题目如下：
 
-* [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)
+* [27.移除元素](https://programmercarl.com/0027.移除元素.html)
+* [15.三数之和](https://programmercarl.com/0015.三数之和.html)
+* [18.四数之和](https://programmercarl.com/0018.四数之和.html)
 
 
 操作链表：
 
-* [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)
+* [206.反转链表](https://programmercarl.com/0206.翻转链表.html)
+* [19.删除链表的倒数第N个节点](https://programmercarl.com/0019.删除链表的倒数第N个节点.html)
+* [面试题 02.07. 链表相交](https://programmercarl.com/面试题02.07.链表相交.html)
+* [142题.环形链表II](https://programmercarl.com/0142.环形链表II.html)
 
 双指针法在字符串题目中还有很多应用，后面还会介绍到。
 
@@ -167,7 +167,33 @@ class Solution {
 
 Python：
 ```python
-
+# 双指针法
+class Solution:
+    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
+        
+        nums.sort()
+        n = len(nums)
+        res = []
+        for i in range(n):
+            if i > 0 and nums[i] == nums[i - 1]: continue
+            for k in range(i+1, n):
+                if k > i + 1 and nums[k] == nums[k-1]: continue
+                p = k + 1
+                q = n - 1
+
+                while p < q:
+                    if nums[i] + nums[k] + nums[p] + nums[q] > target: q -= 1
+                    elif nums[i] + nums[k] + nums[p] + nums[q] < target: p += 1
+                    else:
+                        res.append([nums[i], nums[k], nums[p], nums[q]])
+                        while p < q and nums[p] == nums[p + 1]: p += 1
+                        while p < q and nums[q] == nums[q - 1]: q -= 1
+                        p += 1
+                        q -= 1
+        return res
+```
+```python
+# 哈希表法
 class Solution(object):
     def fourSum(self, nums, target):
         """

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

@@ -11,7 +11,7 @@
 
 ## 19.删除链表的倒数第N个节点
 
-题目链接：https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/
+[力扣题目链接](https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/)
 
 给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
 
@@ -41,7 +41,7 @@
 
 分为如下几步：
 
-* 首先这里我推荐大家使用虚拟头结点，这样方面处理删除实际头结点的逻辑，如果虚拟头结点不清楚，可以看这篇： [链表：听说用虚拟头节点会方便很多？](https://mp.weixin.qq.com/s/L5aanfALdLEwVWGvyXPDqA)
+* 首先这里我推荐大家使用虚拟头结点，这样方面处理删除实际头结点的逻辑，如果虚拟头结点不清楚，可以看这篇： [链表：听说用虚拟头节点会方便很多？](https://programmercarl.com/0203.移除链表元素.html)
 
 * 定义fast指针和slow指针，初始值为虚拟头结点，如图：
 
@@ -204,6 +204,31 @@ fun removeNthFromEnd(head: ListNode?, n: Int): ListNode? {
 }
 ```
 
+Swift：
+```swift
+func removeNthFromEnd(_ head: ListNode?, _ n: Int) -> ListNode? {
+    if head == nil {
+        return nil
+    }
+    if n == 0 {
+        return head
+    }
+    let dummyHead = ListNode(-1, head)
+    var fast: ListNode? = dummyHead
+    var slow: ListNode? = dummyHead
+    // fast 前移 n
+    for _ in 0 ..< n {
+        fast = fast?.next
+    }
+    while fast?.next != nil {
+        fast = fast?.next
+        slow = slow?.next
+    }
+    slow?.next = slow?.next?.next
+    return dummyHead.next
+}
+```
+
 -----------------------
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)

problems/0020.有效的括号.md

@@ -12,7 +12,7 @@
 
 # 20. 有效的括号
 
-https://leetcode-cn.com/problems/valid-parentheses/
+[力扣题目链接](https://leetcode-cn.com/problems/valid-parentheses/)
 
 给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。
 
@@ -162,18 +162,44 @@ class Solution {
 
 Python：
 ```python3
+# 方法一，仅使用栈，更省空间
 class Solution:
     def isValid(self, s: str) -> bool:
-        stack = []  # 保存还未匹配的左括号
-        mapping = {")": "(", "]": "[", "}": "{"}
-        for i in s:
-            if i in "([{":  # 当前是左括号，则入栈
-                stack.append(i)
-            elif stack and stack[-1] == mapping[i]:  # 当前是配对的右括号则出栈
+        stack = []
+        
+        for item in s:
+            if item == '(':
+                stack.append(')')
+            elif item == '[':
+                stack.append(']')
+            elif item == '{':
+                stack.append('}')
+            elif not stack or stack[-1] != item:
+                return False
+            else:
                 stack.pop()
-            else:  # 不是匹配的右括号或者没有左括号与之匹配，则返回false
+        
+        return True if not stack else False
+```
+
+```python3
+# 方法二，使用字典
+class Solution:
+    def isValid(self, s: str) -> bool:
+        stack = []
+        mapping = {
+            '(': ')',
+            '[': ']',
+            '{': '}'
+        }
+        for item in s:
+            if item in mapping.keys():
+                stack.append(mapping[item])
+            elif not stack or stack[-1] != item: 
                 return False
-        return stack == []  # 最后必须正好把左括号匹配完
+            else: 
+                stack.pop()
+        return True if not stack else False
 ```
 
 Go：