Merge branch 'master' into master

Author: youngyangyang04

README.md

@@ -372,25 +372,38 @@
 
 通知：开始更新图论内容，图论部分还没有其他语言版本，欢迎录友们提交PR，成为contributor
 
-### 深搜广搜  
-
-* [图论：深度优先搜索理论基础](./problems/图论深搜理论基础.md)
-* [图论：797.所有可能的路径](./problems/0797.所有可能的路径.md)
-* [图论：广度优先搜索理论基础](./problems/图论广搜理论基础.md)
-* [图论：200.岛屿数量.深搜版](./problems/0200.岛屿数量.深搜版.md)
-* [图论：200.岛屿数量.广搜版](./problems/0200.岛屿数量.广搜版.md)
-* [图论：695.岛屿的最大面积](./problems/0695.岛屿的最大面积.md)
-* [图论：1020.飞地的数量](./problems/1020.飞地的数量.md)
-* [图论：130.被围绕的区域](./problems/0130.被围绕的区域.md)
-* [图论：417.太平洋大西洋水流问题](./problems/0417.太平洋大西洋水流问题.md)
-* [图论：827.最大人工岛](./problems/0827.最大人工岛.md)
-* [图论：127. 单词接龙](./problems/0127.单词接龙.md)
-* [图论：841.钥匙和房间](./problems/0841.钥匙和房间.md)
-* [图论：463. 岛屿的周长](./problems/0463.岛屿的周长.md)
-* [图论：并查集理论基础](./problems/图论并查集理论基础.md)
-* [图论：1971. 寻找图中是否存在路径](./problems/1971.寻找图中是否存在路径.md)
-* [图论：684.冗余连接](./problems/0684.冗余连接.md)
-* [图论：685.冗余连接II](./problems/0685.冗余连接II.md)
+1. [图论：理论基础](./problems/kamacoder/图论理论基础.md)
+2. [图论：深度优先搜索理论基础](./problems/kamacoder/图论深搜理论基础.md)
+3. [图论：所有可达路径](./problems/kamacoder/0098.所有可达路径.md)
+4. [图论：广度优先搜索理论基础](./problems/kamacoder/图论广搜理论基础.md)
+5. [图论：岛屿数量.深搜版](./problems/kamacoder/0099.岛屿的数量深搜.md)
+6. [图论：岛屿数量.广搜版](./problems/kamacoder/0099.岛屿的数量广搜.md)
+7. [图论：岛屿的最大面积](./problems/kamacoder/0100.岛屿的最大面积.md)
+8. [图论：孤岛的总面积](./problems/kamacoder/0101.孤岛的总面积.md)
+9. [图论：沉没孤岛](./problems/kamacoder/0102.沉没孤岛.md)
+10. [图论：水流问题](./problems/kamacoder/0103.水流问题.md)
+11. [图论：建造最大岛屿](./problems/kamacoder/0104.建造最大岛屿.md)
+12. [图论：字符串接龙](./problems/kamacoder/0110.字符串接龙.md)
+13. [图论：有向图的完全可达性](./problems/kamacoder/0105.有向图的完全可达性.md)
+14. [图论：岛屿的周长](./problems/kamacoder/0106.岛屿的周长.md)
+15. [图论：并查集理论基础](./problems/kamacoder/图论并查集理论基础.md)
+16. [图论：寻找存在的路径](./problems/kamacoder/0107.寻找存在的路径.md)
+17. [图论：冗余连接](./problems/kamacoder/0108.冗余连接.md)
+18. [图论：冗余连接II](./problems/kamacoder/0109.冗余连接II.md)
+19. [图论：最小生成树之prim](./problems/kamacoder/0053.寻宝-prim.md)
+20. [图论：最小生成树之kruskal](./problems/kamacoder/0053.寻宝-Kruskal.md)
+21. [图论：拓扑排序](./problems/kamacoder/0117.软件构建.md)
+22. [图论：dijkstra（朴素版）](./problems/kamacoder/0047.参会dijkstra朴素.md)
+23. [图论：dijkstra（堆优化版）](./problems/kamacoder/0047.参会dijkstra堆.md)
+24. [图论：Bellman_ford 算法](./problems/kamacoder/0094.城市间货物运输I.md)
+25. [图论：Bellman_ford 队列优化算法（又名SPFA）](./problems/kamacoder/0094.城市间货物运输I-SPFA.md)
+26. [图论：Bellman_ford之判断负权回路](./problems/kamacoder/0095.城市间货物运输II.md)
+27. [图论：Bellman_ford之单源有限最短路](./problems/kamacoder/0095.城市间货物运输II.md)
+28. [图论：Floyd 算法](./problems/kamacoder/0097.小明逛公园.md)
+29. [图论：A * 算法](./problems/kamacoder/0126.骑士的攻击astar.md)
+30. [图论：最短路算法总结篇](./problems/kamacoder/最短路问题总结篇.md)
+31. [图论：图论总结篇](./problems/kamacoder/图论总结篇.md)
+
 
 （持续更新中....）
 

problems/0015.三数之和.md

@@ -403,6 +403,7 @@ class Solution:
 ```
 
 ### Go：
+（版本一） 双指针
 
 ```Go
 func threeSum(nums []int) [][]int {
@@ -442,6 +443,42 @@ func threeSum(nums []int) [][]int {
 	return res
 }
 ```
+（版本二） 哈希解法
+
+```Go
+func threeSum(nums []int) [][]int {
+    res := make([][]int, 0)
+    sort.Ints(nums)
+    // 找出a + b + c = 0
+    // a = nums[i], b = nums[j], c = -(a + b)
+    for i := 0; i < len(nums); i++ {
+        // 排序之后如果第一个元素已经大于零，那么不可能凑成三元组
+        if nums[i] > 0 {
+            break
+        }
+        // 三元组元素a去重
+        if i > 0 && nums[i] == nums[i-1] {
+            continue
+        }
+        set := make(map[int]struct{})
+        for j := i + 1; j < len(nums); j++ {
+            // 三元组元素b去重
+            if j > i + 2 && nums[j] == nums[j-1] && nums[j-1] == nums[j-2] {
+                continue
+            }
+            c := -nums[i] - nums[j]
+            if _, ok := set[c]; ok {
+                res = append(res, []int{nums[i], nums[j], c})
+                // 三元组元素c去重
+                delete(set, c)
+            } else {
+                set[nums[j]] = struct{}{}
+            }
+        }
+    }
+    return res
+}
+```
 
 ### JavaScript: 
 

problems/0018.四数之和.md

@@ -151,6 +151,96 @@ if (nums[k] + nums[i] > target && nums[i] >= 0) {
 
 ## 其他语言版本
 
+### C:
+
+```C
+/* qsort */
+static int cmp(const void* arg1, const void* arg2) {
+    int a = *(int *)arg1;
+    int b = *(int *)arg2;
+    return (a > b);
+}
+
+int** fourSum(int* nums, int numsSize, int target, int* returnSize, int** returnColumnSizes) {
+
+    /* 对nums数组进行排序 */
+    qsort(nums, numsSize, sizeof(int), cmp);
+
+    int **res = (int **)malloc(sizeof(int *) * 40000);
+    int index = 0;
+
+    /* k */
+    for (int k = 0; k < numsSize - 3; k++) { /* 第一级 */
+
+        /* k剪枝 */
+        if ((nums[k] > target) && (nums[k] >= 0)) {
+            break;
+        }
+        /* k去重 */
+        if ((k > 0) && (nums[k] == nums[k - 1])) {
+            continue;
+        }
+
+        /* i */
+        for (int i = k + 1; i < numsSize - 2; i++) { /* 第二级 */
+
+            /* i剪枝 */
+            if ((nums[k] + nums[i] > target) && (nums[i] >= 0)) {
+                break;
+            }
+            /* i去重 */
+            if ((i > (k + 1)) && (nums[i] == nums[i - 1])) {
+                continue;
+            }
+
+            /* left and right */
+            int left = i + 1;
+            int right = numsSize - 1;
+
+            while (left < right) {
+
+                /* 防止大数溢出 */
+                long long val = (long long)nums[k] + nums[i] + nums[left] + nums[right];
+                if (val > target) {
+                    right--;
+                } else if (val < target) {
+                    left++;
+                } else {
+                    int *res_tmp = (int *)malloc(sizeof(int) * 4);
+                    res_tmp[0] = nums[k];
+                    res_tmp[1] = nums[i];
+                    res_tmp[2] = nums[left];
+                    res_tmp[3] = nums[right];
+                    res[index++] = res_tmp;
+                    
+                    /* right去重 */
+                    while ((right > left) && (nums[right] == nums[right - 1])) {
+                        right--;
+                    }
+                    /* left去重 */
+                    while ((left < right) && (nums[left] == nums[left + 1])) {
+                        left++;
+                    }
+
+                    /* 更新right与left */
+                    left++, right--;
+                }
+            }
+        }
+    }
+
+    /* 返回值处理 */
+    *returnSize = index;
+
+    int *column = (int *)malloc(sizeof(int) * index);
+    for (int i = 0; i < index; i++) {
+        column[i] = 4;
+    }
+    *returnColumnSizes = column;
+    return res;
+}
+```
+
 ### Java：
 
 ```Java

problems/0054.螺旋矩阵.md

@@ -200,6 +200,66 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    public List<Integer> spiralOrder(int[][] matrix) {
+        List<Integer> res = new ArrayList<>(); // 存放结果
+        if (matrix.length == 0 || matrix[0].length == 0)
+            return res;
+        int rows = matrix.length, columns = matrix[0].length;
+        int startx = 0, starty = 0;  // 定义每循环一个圈的起始位置
+        int loop = 0; // 循环次数
+        int offset = 1; // 每一圈循环，需要控制每一条边遍历的长度
+        while (loop < Math.min(rows, columns) / 2) {
+            int i = startx;
+            int j = starty;
+            // 模拟填充上行从左到右(左闭右开)
+            for (; j < columns - offset; j++) {
+                res.add(matrix[i][j]);
+            }
+            // 模拟填充右列从上到下(左闭右开)
+            for (; i < rows - offset; i++) {
+                res.add(matrix[i][j]);
+            }
+            // 模拟填充下行从右到左(左闭右开)
+            for (; j > starty; j--) {
+                res.add(matrix[i][j]);
+            }
+            // 模拟填充左列从下到上(左闭右开)
+            for (; i > startx; i--) {
+                res.add(matrix[i][j]);
+            }
+
+            // 起始位置加1 循环次数加1 并控制每条边遍历的长度
+            startx++;
+            starty++;
+            offset++;
+            loop++;
+        }
+
+        // 如果列或行中的最小值为奇数 则一定有未遍历的部分
+        // 可以自行画图理解
+        if (Math.min(rows, columns) % 2 == 1) {
+            // 当行大于列时 未遍历的部分是列
+            // (startx, starty)即下一个要遍历位置 从该位置出发 遍历完未遍历的列
+            // 遍历次数为rows - columns + 1
+            if (rows > columns) {
+                for (int i = 0; i < rows - columns + 1; i++) {
+                    res.add(matrix[startx++][starty]);
+                }
+            } else {
+                // 此处与上面同理 遍历完未遍历的行
+                for (int i = 0; i < columns - rows + 1; i++) {
+                    res.add(matrix[startx][starty++]);
+                }
+            }
+        }
+
+        return res;
+    }
+}
+```
+
 ### Javascript
 ```
 /**

problems/0063.不同路径II.md

@@ -550,6 +550,27 @@ function uniquePathsWithObstacles(obstacleGrid: number[][]): number {
 };
 ```
 
+// 版本二: dp改為使用一維陣列，從終點開始遍歷
+```typescript
+function uniquePathsWithObstacles(obstacleGrid: number[][]): number {
+  const m = obstacleGrid.length;
+  const n = obstacleGrid[0].length;
+  
+  const dp: number[] = new Array(n).fill(0);
+  dp[n - 1] = 1;
+
+  // 由下而上，右而左進行遍歷
+  for (let i = m - 1; i >= 0; i--) {
+    for (let j = n - 1; j >= 0; j--) {
+      if (obstacleGrid[i][j] === 1) dp[j] = 0;
+      else dp[j] = dp[j] + (dp[j + 1] || 0); 
+    }
+  }
+
+  return dp[0];
+};
+```
+
 ### Rust
 
 ```Rust

problems/0101.对称二叉树.md

@@ -224,8 +224,8 @@ public:
         st.push(root->left);
         st.push(root->right);
         while (!st.empty()) {
-            TreeNode* leftNode = st.top(); st.pop();
             TreeNode* rightNode = st.top(); st.pop();
+            TreeNode* leftNode = st.top(); st.pop();
             if (!leftNode && !rightNode) {
                 continue;
             }
@@ -950,3 +950,4 @@ public bool IsSymmetric(TreeNode root)
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
 </a>
+

problems/0102.二叉树的层序遍历.md

@@ -201,7 +201,7 @@ class Solution:
         return result
 ```
 ```python
-# 递归法
+#递归法
 # Definition for a binary tree node.
 # class TreeNode:
 #     def __init__(self, val=0, left=None, right=None):
@@ -210,18 +210,24 @@ class Solution:
 #         self.right = right
 class Solution:
     def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        if not root:
+            return []
+
         levels = []
-        self.helper(root, 0, levels)
+
+        def traverse(node, level):
+            if not node:
+                return
+
+            if len(levels) == level:
+                levels.append([])
+
+            levels[level].append(node.val)
+            traverse(node.left, level + 1)
+            traverse(node.right, level + 1)
+
+        traverse(root, 0)
         return levels
-    
-    def helper(self, node, level, levels):
-        if not node:
-            return
-        if len(levels) == level:
-            levels.append([])
-        levels[level].append(node.val)
-        self.helper(node.left, level + 1, levels)
-        self.helper(node.right, level + 1, levels)
 
 ```
 

problems/0151.翻转字符串里的单词.md

@@ -467,6 +467,13 @@ class Solution:
         # 将列表转换成字符串
         return " ".join(words)
 ```
+(版本三) 拆分字符串 + 反转列表
+```python
+class Solution:
+    def reverseWords(self, s):
+        words = s.split() #type(words) --- list
+        words = words[::-1] # 反转单词
+        return ' '.join(words) #列表转换成字符串
 
 ### Go：