1.5 LeetCode总结（线性表）_哈希表类

原创

已于 2025-09-21 17:04:36 修改 · 430 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #散列表 #算法

于 2021-03-14 23:16:42 首次发布

本文深入探讨了哈希结构的设计与实现，包括哈希集合、哈希映射等数据结构的具体应用，并通过解决LeetCode上的经典题目如两个数组的交集、设计哈希集合等问题来加深理解。

编程总结

每每刷完一道题后，其思想和精妙之处没有地方记录，本篇博客用以记录刷题过程中的遇到的算法和技巧

242. 有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
示例 1:
输入: s = “anagram”, t = “nagaram”
输出: true
示例 2:
输入: s = “rat”, t = “car”
输出: false
提示:
1 <= s.length, t.length <= 5 * 104
s 和 t 仅包含小写字母

bool isAnagram(char *s, char *t)
{
   
   
	int len_s = strlen(s), len_t = strlen(t);
	if (len_s != len_t) {
   
   
		return false;
	}
	int Hashtable[26];
	memset(Hashtable, 0, sizeof(Hashtable));
	for (int i = 0; i < len_s; ++i) {
   
   
		Hashtable[s[i] - 'a']++;
	}
	for (int i = 0; i < len_t; ++i) {
   
   
		Hashtable[t[i] - 'a']--;
		if (Hashtable[t[i] - 'a'] < 0) {
   
   
			return false;
		}
	}
	return true;
}

349. 两个数组的交集

给定两个数组 nums1 和 nums2 ，返回它们的交集。输出结果中的每个元素一定是唯一的。我们可以不考虑输出结果的顺序。
示例 1：
输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]
示例 2：
输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4]
解释：[4,9] 也是可通过的
提示：
1 <= nums1.length, nums2.length <= 1000
0 <= nums1[i], nums2[i] <= 1000

int *intersection(int *nums1, int nums1Size, int *nums2, int nums2Size, int *returnSize)
{
   
   
    int nums1Cnt[1001] = {
   
    0 };
    int lessSize = fmin(nums1Size, nums2Size);
    int *result  = (int *)malloc(lessSize * sizeof(int));
    int idx = 0;
    /* Calculate the number's counts for nums1 array */
    for (int i = 0; i < nums1Size; i++) {
   
   
        nums1Cnt[nums1[i]]++;
    }
    /* Check if the value in nums2 is existing in nums1 count array */
    for (int i = 0; i < nums2Size; i++) {
   
   
        if (nums1Cnt[nums2[i]] > 0) {
   
   
            result[idx] = nums2[i];
            idx++;
            /* Clear this count to avoid duplicated value */
            nums1Cnt[nums2[i]] = 0;
        }
    }
    *returnSize = idx;
    return result;
}

1.两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出和为目标值 target 的那两个整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案，并且你不能使用两次相同的元素。
你可以按任意顺序返回答案。
示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：
输入：nums = [3,2,4], target = 6
输出：[1,2]
示例 3：
输入：nums = [3,3], target = 6
输出：[0,1]
提示：
2 <= nums.length <= 10^4
-10^9 <= nums[i] <= 10^9
-10^9 <= target <= 10^9
只会存在一个有效答案

struct HashTable {
   
   
    int key;
    int val;
    UT_hash_handle hh; // hash handle（哈希句柄）的缩写
};
struct HashTable *hashtable;
// 查找 
struct HashTable *find(int ikey)
{
   
   
    struct HashTable *tmp;
    HASH_FIND_INT(hashtable, &ikey, tmp);
    return tmp;
}
// 插入
void insert(int ikey, int ival)
{
   
   
    struct HashTable *it = find(ikey);
    if (it == NULL) {
   
   
        struct HashTable *tmp = malloc(sizeof(struct HashTable));
        tmp->key = ikey;
        tmp->val = ival;
        HASH_ADD_INT(hashtable, key, tmp); // 注意uthash里面有key的定义，函数不能再出现key的变量声明
    } else {
   
   
        it->val = ival;
    }
}
int *twoSum(int *nums, int numsSize, int target, int *returnSize)
{
   
   
    hashtable = NULL;
    for (int i = 0; i < numsSize; i++) {
   
   
        struct HashTable *it = find(target - nums[i]);
        if (it != NULL) {
   
   
            int *ret = malloc(sizeof(int) * 2);
            ret[0] = it->val;
            ret[1] = i;
            *returnSize = 2;
            return ret;
        }
        insert(nums[i], i);
    }
    *returnSize = 0;
    return NULL;
}
int main()
{
   
   
    int nums[4] = {
   
   2, 7, 11, 15};
    int numsSize = 4;
    int target = 9;
    int returnSize;
    int *ret = twoSum(nums, numsSize, target, &returnSize);
    for (int i = 0; i < returnSize; i++) {
   
   
        printf("%d ", ret[i]);
    }
	return 0;
}