Merge branch 'master' into master

Author: youngyangyang04

README.md

@@ -23,11 +23,17 @@
 
 很多刚开始刷题的同学都有一个困惑：面对leetcode上近两千道题目，从何刷起。
 
+大家平时刷题感觉效率低，浪费的时间主要在三点：
+
+* 找题
+* 找到了不应该现阶段做的题
+* 没有全套的优质题解可以参考
+
 其实我之前在知乎上回答过这个问题，回答内容大概是按照如下类型来刷数组-> 链表-> 哈希表->字符串->栈与队列->树->回溯->贪心->动态规划->图论->高级数据结构，再从简单刷起，做了几个类型题目之后，再慢慢做中等题目、困难题目。
 
 但我能设身处地的感受到：即使有这样一个整体规划，对于一位初学者甚至算法老手寻找合适自己的题目也是很困难，时间成本很高，而且题目还不一定就是经典题目。
 
-对于刷题，我们都是想用最短的时间把经典题目都做一篇，这样效率才是最高的！
+对于刷题，我们都是想用最短的时间**按照循序渐进的难度顺序把经典题目都做一遍**，这样效率才是最高的！
 
 所以我整理了leetcode刷题攻略：一个超级详细的刷题顺序，**每道题目都是我精心筛选，都是经典题目高频面试题**，大家只要按照这个顺序刷就可以了，**你没看错，就是题目顺序都排好了，文章顺序就是刷题顺序！挨个刷就可以，不用自己再去题海里选题了！**
 
@@ -49,15 +55,18 @@
 
 **目前已经更新了，数组-> 链表-> 哈希表->字符串->栈与队列->树->回溯->贪心，八个专题了，正在讲解动态规划！**
 
-在刷题指南中，每个专题开始都有理论基础篇，并不像是教科书般的理论介绍，而是从实战中归纳需要的基础知识。每个专题结束都有总结篇，最这个专题的归纳总结。
+在刷题攻略中，每个专题开始都有理论基础篇，并不像是教科书般的理论介绍，而是从实战中归纳需要的基础知识。每个专题结束都有总结篇，最这个专题的归纳总结。
 
 如果你是算法老手，这篇攻略也是复习的最佳资料，如果把每个系列对应的总结篇，快速过一遍，整个算法知识体系以及各种解法就重现脑海了。
 
-在按照如下顺序刷题的过程中，每一道题解一定要看对应文章下面的留言（留言目前只能在手机端查看）。
 
-如果你有疑问或者发现文章哪里有不对的地方，都可以在留言区都能找到答案，还有很多录友的总结非常赞，看完之后也很有收获。
+目前「代码随想录」刷题攻略更新了：**200多篇文章，精讲了200道经典算法题目，共60w字的详细图解，部分难点题目还搭配了20分钟左右的视频讲解**。
+
+**这里每一篇题解，都是精品，值得仔细琢磨**。
+
+我在题目讲解中统一用C++语言，但你会发现下面几乎每篇题解都配有其他语言版本，Java、Python、Go、JavaScript等等，这正是热心小伙们的贡献的代码，当然我也会严格把控代码质量。 
 
-目前「代码随想录」刷题指南更新了：**200多篇文章，精讲了200道经典算法题目，共60w字的详细图解，部分难点题目还搭配了20分钟左右的视频讲解**。
+**所以也欢迎大家参与进来，完善题解的各个语言版本，拥抱开源，让更多小伙伴们收益**。
 
 准备好了么，刷题攻略开始咯，go go go！
 
@@ -66,7 +75,7 @@
 ## 前序
 
 * [「代码随想录」后序安排](https://mp.weixin.qq.com/s/4eeGJREy6E-v6D7cR_5A4g)
-* [「代码随想录」学习社区](https://mp.weixin.qq.com/s/X1XCH-KevURi3LnakJsCkA)
+* [「代码随想录」学习社区](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
 
 
 * 编程语言
@@ -119,8 +128,9 @@
 4. [链表：听说过两天反转链表又写不出来了？](./problems/0206.翻转链表.md) 
 5. [链表：两两交换链表中的节点](./problems/0024.两两交换链表中的节点.md)
 6. [链表：删除链表的倒数第 N 个结点](./problems/0019.删除链表的倒数第N个节点.md)
-7. [链表：环找到了，那入口呢？](./problems/0142.环形链表II.md)
-8. [链表：总结篇！](./problems/链表总结篇.md)
+7. [链表：链表相交](./problems/面试题02.07.链表相交.md)
+8. [链表：环找到了，那入口呢？](./problems/0142.环形链表II.md)
+9. [链表：总结篇！](./problems/链表总结篇.md)
 
 ## 哈希表
 
@@ -156,11 +166,13 @@
 3. [字符串：替换空格](./problems/剑指Offer05.替换空格.md)
 4. [字符串：花式反转还不够！](./problems/0151.翻转字符串里的单词.md)
 5. [链表：听说过两天反转链表又写不出来了？](./problems/0206.翻转链表.md)
-6. [链表：环找到了，那入口呢？](./problems/0142.环形链表II.md)
-7. [链表：删除链表的倒数第 N 个结点](./problems/0019.删除链表的倒数第N个节点.md)
-8. [哈希表：解决了两数之和，那么能解决三数之和么？](./problems/0015.三数之和.md)
-9. [双指针法：一样的道理，能解决四数之和](./problems/0018.四数之和.md)
-10. [双指针法：总结篇！](./problems/双指针总结.md)
+6. [链表：删除链表的倒数第 N 个结点](./problems/0019.删除链表的倒数第N个节点.md)
+7. [链表：链表相交](./problems/面试题02.07.链表相交.md)
+8. [链表：环找到了，那入口呢？](./problems/0142.环形链表II.md)
+9. [链表：删除链表的倒数第 N 个结点](./problems/0019.删除链表的倒数第N个节点.md)
+10. [哈希表：解决了两数之和，那么能解决三数之和么？](./problems/0015.三数之和.md)
+11. [双指针法：一样的道理，能解决四数之和](./problems/0018.四数之和.md)
+12. [双指针法：总结篇！](./problems/双指针总结.md)
 
 ## 栈与队列
 

problems/0020.有效的括号.md

@@ -162,6 +162,33 @@ class Solution {
         return deque.isEmpty();
     }
 }
+// 方法2
+class Solution {
+    public boolean isValid(String s) {
+
+        Stack<Character> stack = new Stack<>();
+        Map<Character, Character> map = new HashMap<Character, Character>() {
+            {
+                put('}', '{');
+                put(']', '[');
+                put(')', '(');
+            }
+        };
+
+        for (Character c : s.toCharArray()) {               // 顺序读取字符
+            if (!stack.isEmpty() && map.containsKey(c)) {   // 是右括号 && 栈不为空
+                if (stack.peek() == map.get(c)) {               // 取其对应的左括号直接和栈顶比
+                    stack.pop();                                // 相同则抵消，出栈
+                } else {        
+                    return false;                               // 不同则直接返回
+                }
+            } else {                                
+                stack.push(c);                              // 左括号，直接入栈
+            }
+        }
+        return stack.isEmpty();                             // 看左右是否抵消完
+    }
+}
 ```
 
 Python：

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

@@ -87,6 +87,46 @@ public:
 
 Java：
 
+```Java
+// 递归版本
+class Solution {
+    public ListNode swapPairs(ListNode head) {
+        // base case 退出提交
+        if(head == null || head.next == null) return head;
+        // 获取当前节点的下一个节点
+        ListNode next = head.next;
+        // 进行递归
+        ListNode newNode = swapPairs(next.next);
+        // 这里进行交换
+        next.next = head;
+        head.next = newNode;
+
+        return next;
+    }
+} 
+```
+
+```java
+// 虚拟头结点
+class Solution {
+  public ListNode swapPairs(ListNode head) {
+
+    ListNode dummyNode = new ListNode(0);
+    dummyNode.next = head;
+    ListNode prev = dummyNode;
+
+    while (prev.next != null && prev.next.next != null) {
+      ListNode temp = head.next.next; // 缓存 next
+      prev.next = head.next;          // 将 prev 的 next 改为 head 的 next
+      head.next.next = head;          // 将 head.next(prev.next) 的next，指向 head
+      head.next = temp;               // 将head 的 next 接上缓存的temp
+      prev = head;                    // 步进1位
+      head = head.next;               // 步进1位
+    }
+    return dummyNode.next;
+  }
+}
+```
 
 Python：
 

problems/0035.搜索插入位置.md

@@ -116,7 +116,7 @@ public:
 
 **大家要仔细看注释，思考为什么要写while(left <= right)， 为什么要写right = middle - 1**。
 
-```
+```C++
 class Solution {
 public:
     int searchInsert(vector<int>& nums, int target) {
@@ -158,7 +158,7 @@ public:
 
 **大家要仔细看注释，思考为什么要写while (left < right)， 为什么要写right = middle**。
 
-```
+```C++
 class Solution {
 public:
     int searchInsert(vector<int>& nums, int target) {

problems/0045.跳跃游戏II.md

@@ -175,7 +175,22 @@ class Solution {
 ```
 
 Python：
-
+```python
+class Solution:
+    def jump(self, nums: List[int]) -> int:
+        if len(nums) == 1: return 0
+        ans = 0
+        curDistance = 0
+        nextDistance = 0
+        for i in range(len(nums)):
+            nextDistance = max(i + nums[i], nextDistance)
+            if i == curDistance: 
+                if curDistance != len(nums) - 1:
+                    ans += 1
+                    curDistance = nextDistance
+                    if nextDistance >= len(nums) - 1: break
+        return ans
+```
 
 Go：
 

problems/0046.全排列.md

@@ -149,6 +149,7 @@ public:
 Java：
 ```java
 class Solution {
+
     List<List<Integer>> result = new ArrayList<>();// 存放符合条件结果的集合
     LinkedList<Integer> path = new LinkedList<>();// 用来存放符合条件结果
     boolean[] used;
@@ -167,9 +168,6 @@ class Solution {
             return;
         }
         for (int i = 0; i < nums.length; i++){
-            // if (path.contains(nums[i])){
-            //     continue;
-            // }
             if (used[i]){
                 continue;
             }
@@ -187,6 +185,26 @@ Python：
 
 
 Go：
+```Go
+var result [][]int
+func backtrack(nums,pathNums []int,used []bool){
+    if len(nums)==len(pathNums){
+        tmp:=make([]int,len(nums))
+        copy(tmp,pathNums)
+        result=append(result,tmp)
+        //result=append(result,pathNums)
+        return 
+    }
+    for i:=0;i<len(nums);i++{
+        if !used[i]{
+            used[i]=true
+            pathNums=append(pathNums,nums[i])
+            backtrack(nums,pathNums,used)
+            pathNums=pathNums[:len(pathNums)-1]
+            used[i]=false
+        }
+    }
+}
 
 Javascript:
 ```Javascript

problems/0047.全排列II.md

@@ -85,7 +85,7 @@ public:
         path.clear();
         sort(nums.begin(), nums.end()); // 排序
         vector<bool> used(nums.size(), false);
-        backtracking(nums, vec, used);
+        backtracking(nums, used);
         return result;
     }
 };

problems/0051.N皇后.md

@@ -363,7 +363,72 @@ Python：
 
 
 Go：
+```Go
+import "strings"
+var res [][]string
+
+func isValid(board [][]string, row, col int) (res bool){
+    n := len(board)
+    for i:=0; i < row; i++ {
+        if board[i][col] == "Q" {
+            return false
+        }
+    }
+    for i := 0; i < n; i++{
+        if board[row][i] == "Q" {
+            return false
+        }
+    }
+
+    for i ,j := row, col; i >= 0 && j >=0 ; i, j = i - 1, j- 1{
+        if board[i][j] == "Q"{
+            return false
+        }
+    }
+    for i, j := row, col; i >=0 && j < n; i,j = i-1, j+1 {
+        if board[i][j] == "Q" {
+            return false
+        }
+    }
+    return true
+}
+
+func backtrack(board [][]string, row int) {
+    size := len(board)
+    if row == size{
+        temp := make([]string, size)
+        for i := 0; i<size;i++{
+            temp[i] = strings.Join(board[i],"")
+        }
+        res =append(res,temp)
+        return 
+    }
+    for col := 0; col < size; col++ {
+        if !isValid(board, row, col){
+            continue
+        }
+        board[row][col] = "Q"
+        backtrack(board, row+1)
+        board[row][col] = "."
+    }
+}
 
+func solveNQueens(n int) [][]string {
+    res = [][]string{}
+    board := make([][]string, n)
+    for i := 0; i < n; i++{
+        board[i] = make([]string, n)
+    }
+    for i := 0; i < n; i++{
+        for j := 0; j<n;j++{
+            board[i][j] = "."
+        }
+    }
+    backtrack(board, 0)
+
+    return res
+}
+```
 
 
 

problems/0053.最大子序和.md

@@ -175,31 +175,25 @@ class Solution:
 ```
 
 Go：
-```Go
-func maxSubArray(nums []int) int {
-    if len(nums)<1{
-        return 0
-    }
-    dp:=make([]int,len(nums))
-    result:=nums[0]
-    dp[0]=nums[0]
-    for i:=1;i<len(nums);i++{
-        dp[i]=max(dp[i-1]+nums[i],nums[i])
-        result=max(dp[i],result)
-    }
-    return result
-}
 
-func max(a,b int)int{
-    if a>b{
-        return a
-    }else{
-        return b
+```go
+func maxSubArray(nums []int) int {
+    maxSum := nums[0]
+    for i := 1; i < len(nums); i++ {
+        if nums[i] + nums[i-1] > nums[i] {
+            nums[i] += nums[i-1]
+        }
+        if nums[i] > maxSum {
+            maxSum = nums[i]
+        }
     }
+    return maxSum
 }
 ```
 
 
+
+
 -----------------------
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)