Merge branch 'youngyangyang04:master' into master

Author: Jerry-306

.DS_Store

@@ -1,6 +1,6 @@
 <p align="center">
-<a href="https://programmercarl.com/other/kstar.html" target="_blank">
-  <img src="https://code-thinking-1253855093.file.myqcloud.com/pics/20210924105952.png" width="1000"/>
+<a href="https://programmercarl.com/other/xunlianying.html" target="_blank">
+  <img src="../pics/训练营.png" width="1000"/>
 </a>
 <p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
 
@@ -24,15 +24,26 @@
 
 ## 思路
 
-很明显暴力的解法是两层for循环查找，时间复杂度是$O(n^2)$。
+建议看一下我录的这期视频：[梦开始的地方，Leetcode：1.两数之和](https://www.bilibili.com/video/BV1aT41177mK)，结合本题解来学习，事半功倍。
+
+很明显暴力的解法是两层for循环查找，时间复杂度是O(n^2)。
 
 建议大家做这道题目之前，先做一下这两道
 * [242. 有效的字母异位词](https://www.programmercarl.com/0242.有效的字母异位词.html)
 * [349. 两个数组的交集](https://www.programmercarl.com/0349.两个数组的交集.html)
 
 [242. 有效的字母异位词](https://www.programmercarl.com/0242.有效的字母异位词.html) 这道题目是用数组作为哈希表来解决哈希问题，[349. 两个数组的交集](https://www.programmercarl.com/0349.两个数组的交集.html)这道题目是通过set作为哈希表来解决哈希问题。
 
-本题呢，则要使用map，那么来看一下使用数组和set来做哈希法的局限。
+
+首先我在强调一下 **什么时候使用哈希法**，当我们需要查询一个元素是否出现过，或者一个元素是否在集合里的时候，就要第一时间想到哈希法。 
+
+本题呢，我就需要一个集合来存放我们遍历过的元素，然后在遍历数组的时候去询问这个集合，某元素是否遍历过，也就是 是否出现在这个集合。
+
+那么我们就应该想到使用哈希法了。
+
+因为本地，我们不仅要知道元素有没有遍历过，还有知道这个元素对应的下标，**需要使用 key value结构来存放，key来存元素，value来存下标，那么使用map正合适**。 
+
+再来看一下使用数组和set来做哈希法的局限。
 
 * 数组的大小是受限制的，而且如果元素很少，而哈希值太大会造成内存空间的浪费。
 * set是一个集合，里面放的元素只能是一个key，而两数之和这道题目，不仅要判断y是否存在而且还要记录y的下标位置，因为要返回x 和 y的下标。所以set 也不能用。
@@ -43,20 +54,39 @@ C++中map，有三种类型：
 
 |映射 |底层实现 | 是否有序 |数值是否可以重复 | 能否更改数值|查询效率 |增删效率|
 |---|---| --- |---| --- | --- | ---|
-|std::map |红黑树 |key有序 |key不可重复 |key不可修改 | $O(\log n)$|$O(\log n)$ |
-|std::multimap | 红黑树|key有序 | key可重复 | key不可修改|$O(\log n)$ |$O(\log n)$ |
-|std::unordered_map |哈希表 | key无序 |key不可重复 |key不可修改 |$O(1)$ | $O(1)$|
+|std::map |红黑树 |key有序 |key不可重复 |key不可修改 | O(log n)|O(log n) |
+|std::multimap | 红黑树|key有序 | key可重复 | key不可修改|O(log n) |O(log n) |
+|std::unordered_map |哈希表 | key无序 |key不可重复 |key不可修改 |O(1) | O(1)|
 
 std::unordered_map 底层实现为哈希表，std::map 和std::multimap 的底层实现是红黑树。
 
 同理，std::map 和std::multimap 的key也是有序的（这个问题也经常作为面试题，考察对语言容器底层的理解）。 更多哈希表的理论知识请看[关于哈希表，你该了解这些！](https://www.programmercarl.com/哈希表理论基础.html)。
 
-**这道题目中并不需要key有序，选择std::unordered_map 效率更高！**
+**这道题目中并不需要key有序，选择std::unordered_map 效率更高！**  使用其他语言的录友注意了解一下自己所用语言的数据结构就行。
+
+接下来需要明确两点： 
+
+* **map用来做什么**
+* **map中key和value分别表示什么**
+
+map目的用来存放我们访问过的元素，因为遍历数组的时候，需要记录我们之前遍历过哪些元素和对应的下标，这样才能找到与当前元素相匹配的（也就是相加等于target）
+
+接下来是map中key和value分别表示什么。 
+
+这道题 我们需要 给出一个元素，判断这个元素是否出现过，如果出现过，返回这个元素的下标。 
+
+那么判断元素是否出现，这个元素就要作为key，所以数组中的元素作为key，有key对应的就是value，value用来存下标。 
 
-解题思路动画如下：
+所以 map中的存储结构为 {key：数据元素，value：数组元素对应的下标}。 
 
-![](https://code-thinking.cdn.bcebos.com/gifs/1.两数之和.gif)
+在遍历数组的时候，只需要向map去查询是否有和目前遍历元素匹配的数值，如果有，就找到的匹配对，如果没有，就把目前遍历的元素放进map中，因为map存放的就是我们访问过的元素。
 
+过程如下：
+
+![过程一](https://code-thinking-1253855093.file.myqcloud.com/pics/20220711202638.png) 
+
+
+![过程二](https://code-thinking-1253855093.file.myqcloud.com/pics/20230220223536.png)
 
 C++代码：
 
@@ -66,18 +96,34 @@ public:
     vector<int> twoSum(vector<int>& nums, int target) {
         std::unordered_map <int,int> map;
         for(int i = 0; i < nums.size(); i++) {
-            auto iter = map.find(target - nums[i]);
+            // 遍历当前元素，并在map中寻找是否有匹配的key
+            auto iter = map.find(target - nums[i]); 
             if(iter != map.end()) {
                 return {iter->second, i};
             }
-            map.insert(pair<int, int>(nums[i], i));
+            // 如果没找到匹配对，就把访问过的元素和下标加入到map中
+            map.insert(pair<int, int>(nums[i], i)); 
         }
         return {};
     }
 };
 ```
 
+* 时间复杂度: O(n)
+* 空间复杂度: O(n)
+
+## 总结 
+
+本题其实有四个重点： 
+
+* 为什么会想到用哈希表 
+* 哈希表为什么用map 
+* 本题map是用来存什么的 
+* map中的key和value用来存什么的 
 
+把这四点想清楚了，本题才算是理解透彻了。
+
+很多录友把这道题目 通过了，但都没想清楚map是用来做什么的，以至于对代码的理解其实是 一知半解的。 
 
 
 ## 其他语言版本
@@ -92,12 +138,13 @@ public int[] twoSum(int[] nums, int target) {
     }
     Map<Integer, Integer> map = new HashMap<>();
     for(int i = 0; i < nums.length; i++){
-        int temp = target - nums[i];
+        int temp = target - nums[i];   // 遍历当前元素，并在map中寻找是否有匹配的key
         if(map.containsKey(temp)){
             res[1] = i;
             res[0] = map.get(temp);
+            break;
         }
-        map.put(nums[i], i);
+        map.put(nums[i], i);    // 如果没找到匹配对，就把访问过的元素和下标加入到map中
     }
     return res;
 }
@@ -110,30 +157,17 @@ class Solution:
     def twoSum(self, nums: List[int], target: int) -> List[int]:
         records = dict()
 
-        # 用枚举更方便，就不需要通过索引再去取当前位置的值
-        for idx, val in enumerate(nums):
-            if target - val not in records:
-                records[val] = idx
-            else:
-                return [records[target - val], idx] # 如果存在就返回字典记录索引和当前索引
-```
-
-Python (v2):
-
-```python
-class Solution:
-    def twoSum(self, nums: List[int], target: int) -> List[int]:
-        rec = {}
-        for i in range(len(nums)):
-            rest = target - nums[i]
-            # Use get to get the index of the data, making use of one of the dictionary properties.
-            if rec.get(rest, None) is not None: return [rec[rest], i]
-            rec[nums[i]] = i
+        for index, value in enumerate(nums):  
+            if target - value in records:   # 遍历当前元素，并在map中寻找是否有匹配的key
+                return [records[target- value], index]
+            records[value] = index    # 遍历当前元素，并在map中寻找是否有匹配的key
+        return []
 ```
 
 Go：
 
 ```go
+// 暴力解法
 func twoSum(nums []int, target int) []int {
     for k1, _ := range nums {
         for k2 := k1 + 1; k2 < len(nums); k2++ {
@@ -188,11 +222,11 @@ Javascript
 ```javascript
 var twoSum = function (nums, target) {
   let hash = {};
-  for (let i = 0; i < nums.length; i++) {
+  for (let i = 0; i < nums.length; i++) {  // 遍历当前元素，并在map中寻找是否有匹配的key
     if (hash[target - nums[i]] !== undefined) {
       return [i, hash[target - nums[i]]];
     }
-    hash[nums[i]] = i;
+    hash[nums[i]] = i;   // 如果没找到匹配对，就把访问过的元素和下标加入到map中
   }
   return [];
 };
@@ -221,13 +255,15 @@ php
 ```php
 function twoSum(array $nums, int $target): array
 {
-    for ($i = 0; $i < count($nums);$i++) {
-        // 计算剩下的数
-        $residue = $target - $nums[$i];
-        // 匹配的index，有则返回index， 无则返回false
-        $match_index = array_search($residue, $nums);
-        if ($match_index !== false && $match_index != $i) {
-            return array($i, $match_index);
+    $map = [];
+    foreach($nums as $i => $num) {
+        if (isset($map[$target - $num])) {
+            return [
+                $i,
+                $map[$target - $num]
+            ];
+        } else {
+            $map[$num] = $i;
         }
     }
     return [];
@@ -250,30 +286,6 @@ func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
 }
 ```
 
-PHP:
-```php
-class Solution {
-    /**
-     * @param Integer[] $nums
-     * @param Integer $target
-     * @return Integer[]
-     */
-    function twoSum($nums, $target) {
-        if (count($nums) == 0) {
-            return [];
-        }
-        $table = [];
-        for ($i = 0; $i < count($nums); $i++) {
-            $temp = $target - $nums[$i];
-            if (isset($table[$temp])) {
-                return [$table[$temp], $i];
-            }
-            $table[$nums[$i]] = $i;
-        }
-        return [];
-    }
-}
-```
 
 Scala:
 ```scala
@@ -317,6 +329,103 @@ public class Solution {
 }
 ```
 
+Dart:
+```dart
+List<int> twoSum(List<int> nums, int target) {  
+    var tmp = [];
+    for (var i = 0; i < nums.length; i++) {
+        var rest = target - nums[i];
+        if(tmp.contains(rest)){
+            return [tmp.indexOf(rest), i];
+        }
+        tmp.add(nums[i]);
+    }
+    return [0 , 0];
+}
+```
+
+C:
+```c
+
+
+/**
+ * Note: The returned array must be malloced, assume caller calls free().
+ */
+
+// leetcode 支持 ut_hash 函式庫
+
+ typedef struct {
+     int key;
+     int value;
+     UT_hash_handle hh; // make this structure hashable
+ } map;
+
+map* hashMap = NULL;
+
+ void hashMapAdd(int key, int value){
+     map* s;
+     // key already in the hash?
+     HASH_FIND_INT(hashMap, &key, s);
+     if(s == NULL){
+         s = (map*)malloc(sizeof(map));
+         s -> key = key;
+         HASH_ADD_INT(hashMap, key, s);
+     }
+     s -> value = value;
+ }
+
+map* hashMapFind(int key){
+     map* s;
+     // *s: output pointer
+     HASH_FIND_INT(hashMap, &key, s);   
+     return s;
+ }
+
+ void hashMapCleanup(){
+     map* cur, *tmp;
+     HASH_ITER(hh, hashMap, cur, tmp){
+         HASH_DEL(hashMap, cur);
+         free(cur);
+     }
+ }
+
+ void hashPrint(){
+     map* s;
+     for(s = hashMap; s != NULL; s=(map*)(s -> hh.next)){
+         printf("key %d, value %d\n", s -> key, s -> value);
+     }
+ }
+
+ 
+int* twoSum(int* nums, int numsSize, int target, int* returnSize){
+    int i, *ans;
+    // hash find result
+    map* hashMapRes; 
+    hashMap = NULL;
+    ans = malloc(sizeof(int) * 2);
+
+    for(i = 0; i < numsSize; i++){
+        // key 代表 nums[i] 的值，value 代表所在 index;
+        hashMapAdd(nums[i], i);
+    }
+
+    hashPrint();
 
------------------------
-<div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>
+    for(i = 0; i < numsSize; i++){
+        hashMapRes = hashMapFind(target - nums[i]);
+        if(hashMapRes && hashMapRes -> value != i){
+            ans[0] = i;
+            ans[1] = hashMapRes -> value ;
+            *returnSize = 2;
+            return ans;
+        }
+    }
+    
+    hashMapCleanup();
+    return NULL;
+}
+```
+<p align="center">
+<a href="https://programmercarl.com/other/kstar.html" target="_blank">
+  <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
+</a>