Merge pull request #1776 from juguagua/leetcode-modify-the-code-of-the-hash

修改完善哈希表部分代码和注释

problems/0001.两数之和.md

@@ -134,12 +134,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;
 }
@@ -153,15 +154,16 @@ class Solution:
         records = dict()
 
         for index, value in enumerate(nums):  
-            if target - value in records:
+            if target - value in records:   # 遍历当前元素，并在map中寻找是否有匹配的key
                 return [records[target- value], index]
-            records[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++ {
@@ -216,11 +218,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 [];
 };

problems/0015.三数之和.md

@@ -253,13 +253,15 @@ class Solution {
     public List<List<Integer>> threeSum(int[] nums) {
         List<List<Integer>> result = new ArrayList<>();
         Arrays.sort(nums);
-
+	// 找出a + b + c = 0
+        // a = nums[i], b = nums[left], c = nums[right]
         for (int i = 0; i < nums.length; i++) {
+	    // 排序之后如果第一个元素已经大于零，那么无论如何组合都不可能凑成三元组，直接返回结果就可以了
             if (nums[i] > 0) { 
                 return result;
             }
 
-            if (i > 0 && nums[i] == nums[i - 1]) {
+            if (i > 0 && nums[i] == nums[i - 1]) {  // 去重a
                 continue;
             }
 
@@ -273,7 +275,7 @@ class Solution {
                     left++;
                 } else {
                     result.add(Arrays.asList(nums[i], nums[left], nums[right]));
-
+		    // 去重逻辑应该放在找到一个三元组之后，对b 和 c去重
                     while (right > left && nums[right] == nums[right - 1]) right--;
                     while (right > left && nums[left] == nums[left + 1]) left++;
                     
@@ -294,12 +296,15 @@ class Solution:
         ans = []
         n = len(nums)
         nums.sort()
+	# 找出a + b + c = 0
+        # a = nums[i], b = nums[left], c = nums[right]
         for i in range(n):
             left = i + 1
             right = n - 1
+	    # 排序之后如果第一个元素已经大于零，那么无论如何组合都不可能凑成三元组，直接返回结果就可以了
             if nums[i] > 0: 
                 break
-            if i >= 1 and nums[i] == nums[i - 1]:
+            if i >= 1 and nums[i] == nums[i - 1]: # 去重a
                 continue
             while left < right:
                 total = nums[i] + nums[left] + nums[right]
@@ -309,13 +314,14 @@ class Solution:
                     left += 1
                 else:
                     ans.append([nums[i], nums[left], nums[right]])
+		    # 去重逻辑应该放在找到一个三元组之后，对b 和 c去重
                     while left != right and nums[left] == nums[left + 1]: left += 1
                     while left != right and nums[right] == nums[right - 1]: right -= 1
                     left += 1
                     right -= 1
         return ans
 ```
-Python (v2):
+Python (v3):
 
 ```python
 class Solution:
@@ -347,12 +353,15 @@ Go：
 func threeSum(nums []int) [][]int {
 	sort.Ints(nums)
 	res := [][]int{}
-	
+	// 找出a + b + c = 0
+	// a = nums[i], b = nums[left], c = nums[right]
 	for i := 0; i < len(nums)-2; i++ {
+		// 排序之后如果第一个元素已经大于零，那么无论如何组合都不可能凑成三元组，直接返回结果就可以了
 		n1 := nums[i]
 		if n1 > 0 {
 			break
 		}
+		// 去重a
 		if i > 0 && n1 == nums[i-1] {
 			continue
 		}
@@ -361,6 +370,7 @@ func threeSum(nums []int)[][]int{
 			n2, n3 := nums[l], nums[r]
 			if n1+n2+n3 == 0 {
 				res = append(res, []int{n1, n2, n3})
+				// 去重逻辑应该放在找到一个三元组之后，对b 和 c去重
 				for l < r && nums[l] == n2 {
 					l++
 				}

problems/0018.四数之和.md

@@ -142,19 +142,20 @@ class Solution {
                 return result;
             }
 		
-            if (i > 0 && nums[i - 1] == nums[i]) {
+            if (i > 0 && nums[i - 1] == nums[i]) {    // 对nums[i]去重
                 continue;
             }
             
             for (int j = i + 1; j < nums.length; j++) {
 
-                if (j > i + 1 && nums[j - 1] == nums[j]) {
+                if (j > i + 1 && nums[j - 1] == nums[j]) {  // 对nums[j]去重
                     continue;
                 }
 
                 int left = j + 1;
                 int right = nums.length - 1;
                 while (right > left) {
+		    // nums[k] + nums[i] + nums[left] + nums[right] > target int会溢出
                     long sum = (long) nums[i] + nums[j] + nums[left] + nums[right];
                     if (sum > target) {
                         right--;
@@ -162,7 +163,7 @@ class Solution {
                         left++;
                     } else {
                         result.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
-                        
+                        // 对nums[left]和nums[right]去重
                         while (right > left && nums[right] == nums[right - 1]) right--;
                         while (right > left && nums[left] == nums[left + 1]) left++;
 
@@ -187,9 +188,9 @@ class Solution:
         n = len(nums)
         res = []
         for i in range(n):   
-            if i > 0 and nums[i] == nums[i - 1]: continue
+            if i > 0 and nums[i] == nums[i - 1]: continue  # 对nums[i]去重
             for k in range(i+1, n):
-                if k > i + 1 and nums[k] == nums[k-1]: continue
+                if k > i + 1 and nums[k] == nums[k-1]: continue  # 对nums[k]去重
                 p = k + 1
                 q = n - 1
 
@@ -198,6 +199,7 @@ class Solution:
                     elif nums[i] + nums[k] + nums[p] + nums[q] < target: p += 1
                     else:
                         res.append([nums[i], nums[k], nums[p], nums[q]])
+			# 对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
@@ -258,12 +260,12 @@ func fourSum(nums []int, target int) [][]int {
 		// if n1 > target { // 不能这样写,因为可能是负数
 		// 	break
 		// }
-		if i > 0 && n1 == nums[i-1] {
+		if i > 0 && n1 == nums[i-1] {  // 对nums[i]去重
 			continue
 		}
 		for j := i + 1; j < len(nums)-2; j++ {
 			n2 := nums[j]
-			if j > i+1 && n2 == nums[j-1] {
+			if j > i+1 && n2 == nums[j-1] {  // 对nums[j]去重
 				continue
 			}
 			l := j + 1
@@ -320,6 +322,8 @@ var fourSum = function(nums, target) {
                 if(sum < target) { l++; continue}
                 if(sum > target) { r--; continue}
                 res.push([nums[i], nums[j], nums[l], nums[r]]);
+		
+		// 对nums[left]和nums[right]去重
                 while(l < r && nums[l] === nums[++l]);
                 while(l < r && nums[r] === nums[--r]);
             }

problems/0242.有效的字母异位词.md

@@ -101,7 +101,7 @@ class Solution {
         int[] record = new int[26];
 
         for (int i = 0; i < s.length(); i++) {
-            record[s.charAt(i) - 'a']++;
+            record[s.charAt(i) - 'a']++;     // 并不需要记住字符a的ASCII，只要求出一个相对数值就可以了
         }
 
         for (int i = 0; i < t.length(); i++) {
@@ -109,11 +109,11 @@ class Solution {
         }
         
         for (int count: record) {
-            if (count != 0) {
+            if (count != 0) {               // record数组如果有的元素不为零0，说明字符串s和t 一定是谁多了字符或者谁少了字符。
                 return false;
             }
         }
-        return true;
+        return true;                        // record数组所有元素都为零0，说明字符串s和t是字母异位词
     }
 }
 ```
@@ -166,35 +166,10 @@ class Solution(object):
 
 Go：
 
-```go
-func isAnagram(s string, t string) bool {
-    if len(s)!=len(t){
-        return false
-    }
-    exists := make(map[byte]int)
-    for i:=0;i<len(s);i++{
-        if v,ok:=exists[s[i]];v>=0&&ok{
-            exists[s[i]]=v+1
-        }else{
-            exists[s[i]]=1
-        }
-    }
-    for i:=0;i<len(t);i++{
-        if v,ok:=exists[t[i]];v>=1&&ok{
-            exists[t[i]]=v-1
-        }else{
-            return false
-        }
-    }
-    return true
-}
-```
-
-Go写法二（没有使用slice作为哈希表，用数组来代替）：
-
 ```go
 func isAnagram(s string, t string) bool {
     record := [26]int{}
+    
     for _, r := range s {
         record[r-rune('a')]++
     }
@@ -202,7 +177,7 @@ func isAnagram(s string, t string) bool {
         record[r-rune('a')]--
     }
 
-    return record == [26]int{}
+    return record == [26]int{}   // record数组如果有的元素不为零0，说明字符串s和t 一定是谁多了字符或者谁少了字符。
 }
 ```
 

problems/0349.两个数组的交集.md

@@ -147,32 +147,24 @@ Python3：
 ```python
 class Solution:
     def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
-        return list(set(nums1) & set(nums2))    # 两个数组先变成集合，求交集后还原为数组
+        val_dict = {}
+        ans = []
+        for num in nums1:
+            val_dict[num] = 1
+
+        for num in nums2:
+            if num in val_dict.keys() and val_dict[num] == 1:
+                ans.append(num)
+                val_dict[num] = 0
+        
+        return ans
 ```
 
 
 Go：
 ```go
 func intersection(nums1 []int, nums2 []int) []int {
-    m := make(map[int]int)
+    set:=make(map[int]struct{},0)  // 用map模拟set
-    for _, v := range nums1 {
-        m[v] = 1
-    }
-    var res []int
-    // 利用count>0，实现重复值只拿一次放入返回结果中
-    for _, v := range nums2 {
-        if count, ok := m[v]; ok && count > 0 {
-            res = append(res, v)
-            m[v]--
-        }
-    }
-    return res
-}
-```
-```golang
-//优化版，利用set，减少count统计
-func intersection(nums1 []int, nums2 []int) []int {
-    set:=make(map[int]struct{},0)
     res:=make([]int,0)
     for _,v:=range nums1{
         if _,ok:=set[v];!ok{

problems/0383.赎金信.md

@@ -147,11 +147,11 @@ class Solution:
 
         arr = [0] * 26
 
-        for x in magazine:
+        for x in magazine:    # 记录 magazine里各个字符出现次数
             arr[ord(x) - ord('a')] += 1
 
-        for x in ransomNote:
+        for x in ransomNote:  # 在arr里对应的字符个数做--操作
-            if arr[ord(x) - ord('a')] == 0:
+            if arr[ord(x) - ord('a')] == 0:  # 如果没有出现过直接返回
                 return False
             else:
                 arr[ord(x) - ord('a')] -= 1
@@ -234,12 +234,12 @@ Go：
 ```go
 func canConstruct(ransomNote string, magazine string) bool {
     record := make([]int, 26)
-    for _, v := range magazine {
+    for _, v := range magazine {   // 通过recode数据记录 magazine里各个字符出现次数
         record[v-'a']++
     }
-    for _, v := range ransomNote {
+    for _, v := range ransomNote { // 遍历ransomNote，在record里对应的字符个数做--操作
         record[v-'a']--
-        if record[v-'a'] < 0 {
+        if record[v-'a'] < 0 {     // 如果小于零说明ransomNote里出现的字符，magazine没有
             return false
         }
     }
@@ -258,12 +258,12 @@ javaScript:
 var canConstruct = function(ransomNote, magazine) {
     const strArr = new Array(26).fill(0), 
         base = "a".charCodeAt();
-    for(const s of magazine) {
+    for(const s of magazine) {  // 记录 magazine里各个字符出现次数
         strArr[s.charCodeAt() - base]++;
     }
-    for(const s of ransomNote) {
+    for(const s of ransomNote) { // 对应的字符个数做--操作
         const index = s.charCodeAt() - base;
-        if(!strArr[index]) return false;
+        if(!strArr[index]) return false;  // 如果没记录过直接返回false
         strArr[index]--;
     }
     return true;

problems/0454.四数相加II.md

@@ -168,13 +168,15 @@ Go：
 
 ```go
 func fourSumCount(nums1 []int, nums2 []int, nums3 []int, nums4 []int) int {
-    m := make(map[int]int)
+    m := make(map[int]int)   //key:a+b的数值，value:a+b数值出现的次数
     count := 0
+     // 遍历nums1和nums2数组，统计两个数组元素之和，和出现的次数，放到map中
     for _, v1 := range nums1 {  
         for _, v2 := range nums2 {
             m[v1+v2]++
         }
     }
+    // 遍历nums3和nums4数组，找到如果 0-(c+d) 在map中出现过的话，就把map中key对应的value也就是出现次数统计出来
     for _, v3 := range nums3 {
         for _, v4 := range nums4 {
             count += m[-v3-v4]
@@ -197,14 +199,14 @@ javaScript:
 var fourSumCount = function(nums1, nums2, nums3, nums4) {
     const twoSumMap = new Map();
     let count = 0;
-
+    // 统计nums1和nums2数组元素之和，和出现的次数，放到map中
     for(const n1 of nums1) {
         for(const n2 of nums2) {
             const sum = n1 + n2;
             twoSumMap.set(sum, (twoSumMap.get(sum) || 0) + 1)
         }
     }
-
+    // 找到如果 0-(c+d) 在map中出现过的话，就把map中key对应的value也就是出现次数统计出来
     for(const n3 of nums3) {
         for(const n4 of nums4) {
             const sum = n3 + n4;