刷题笔记:力扣第242、349题（哈希表）

力扣第242题-有效的字母异位词

1.本题考点为哈希表，比较容易想到，完整代码如下：

 1. bool isAnagram(char* s, char* t) {
 2.     // 创建26个字母的计数数组，初始全0
 3.     int hash[26] = {0};
 4.     // 获取两个字符串长度
 5.     int len1 = strlen(s), len2 = strlen(t);
 6.     // 长度不同一定不是字母异位词，直接返回false
 7.     if (len1 != len2) return false;
 8.  
 9.     // 遍历s，对应字母计数+1
10.     for (int i = 0; i < len1; i++){
11.         hash[s[i] - 'a']++;
12.     }
13.     // 遍历t，对应字母计数-1
14.     for (int i = 0; i < len2; i++){
15.         hash[t[i] - 'a']--;
16.         // 某个字母负数，说明t该字母更多，直接false
17.         if (hash[t[i] - 'a'] < 0) return false;
18.     }
19.  
20.     // 全部抵消完毕，是字母异位词
21.     return true;
22. }

该算法时间复杂度为O(n)，空间复杂度为O(1)。

力扣第349题-两个数组的交集

1.本题也是考察哈希表，只需要为两个数组各创建一个哈希数组，记录哪些数字出现了，最后在对比两个哈希数组即可。完整代码如下：

 1. int* intersection(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize) {
 2.     // 哈希数组，题目数据范围0~1000，分别记录两个数组数字出现标记
 3.     int hash1[1001] = {0};
 4.     int hash2[1001] = {0};
 5.     // cnt记录交集元素个数
 6.     int cnt = 0;
 7.     // 分配结果数组，最多存1001个不同数字
 8.     int* res = (int*)malloc(sizeof(int) * 1001);
 9.  
10.     // 遍历nums1，标记出现过的数字
11.     for (int i = 0; i < nums1Size; i++){
12.         hash1[nums1[i]]++;
13.     }
14.     // 遍历nums2，标记出现过的数字
15.     for (int i = 0; i < nums2Size; i++){
16.         hash2[nums2[i]]++;
17.     }
18.     // 遍历0~1000全部数字，两边都出现过则加入交集
19.     for (int i = 0; i < 1001; i++){
20.         if (hash1[i] > 0 && hash2[i] > 0){
21.             res[cnt++] = i;
22.         }
23.     }
24.  
25.     // 设置返回数组长度
26.     *returnSize = cnt;
27.     return res;
28. }

该算法时间复杂度为O(m + n)，空间复杂度为O(1)（常数空间的哈希数组）。

2.还可以做进一步优化，两个哈希数组合并为一个，结果数组的开辟空间大小设定为两个数组大小的较小值。完整代码如下：

 1. int* intersection(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize) {
 2.     // 哈希数组，数值范围0~1000，标记nums1中出现过的数字
 3.     int hash[1001] = {0};
 4.     // 统计交集元素数量
 5.     int cnt = 0;
 6.     // 交集最多元素个数等于较短数组长度，以此分配结果数组内存
 7.     int lessSize = nums1Size < nums2Size ? nums1Size : nums2Size;
 8.     int* res = (int*)malloc(sizeof(int) * lessSize);
 9.  
10.     // 遍历nums1，仅将首次出现的数字标记为1，去重
11.     for (int i = 0; i < nums1Size; i++){
12.         if (hash[nums1[i]] == 0){
13.             hash[nums1[i]]++;
14.         }
15.     }
16.     // 遍历nums2，找到哈希表中标记过的数字，即为交集
17.     for (int i = 0; i < nums2Size; i++){
18.         if (hash[nums2[i]] > 0){
19.             res[cnt++] = nums2[i];
20.             hash[nums2[i]]--; // 减1避免重复存入相同元素
21.         }
22.     }
23.  
24.     // 赋值返回数组有效长度
25.     *returnSize = cnt;
26.     return res;
27. }

该算法时间复杂度为O(m + n)，空间复杂度为O(1)（常数空间的哈希数组）。