[LeetCode] 350.两个数组的交集 II（Easy）C语言题解

最新推荐文章于 2021-07-27 07:07:21 发布

原创最新推荐文章于 2021-07-27 07:07:21 发布 · 745 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#哈希表 #排序 #双指针

LeetCode-C 同时被 2 个专栏收录

26 篇文章

订阅专栏

LeetCode-C

25 篇文章

订阅专栏

博客围绕计算两个数组交集的问题展开，给出示例并说明了数据范围等信息。介绍了两种解题方法，一是使用uthash哈希表，分别记录元素出现次数，时间和空间复杂度均为O(N)；二是先排序再用双指针查找，时间复杂度O(Nlogn)，空间复杂度O(1)。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目

给定两个数组，编写一个函数来计算它们的交集。

示例

①示例1

输入: nums1 = [1,2,2,1], nums2 = [2,2]
输出: [2,2]

②示例2

输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出: [4,9]

说明

输出结果中每个元素出现的次数，应与元素在两个数组中出现的次数一致(即不用去重)。
我们可以不考虑输出结果的顺序。

①数据范围(自测)

-2147483648 ~ 2147483647
| 与 349. 两个数组的交集 — 力扣网相比，数据范围太大且单组数据的数据差也很大，无法用数组模拟的哈希表求解。

②相关话题

哈希表
排序
双指针
二分查找

③相似题目

④题目地址

解题方法

①哈希表

因为数据范围太大，无法用数组模拟的哈希表做，但是可以使用 uthash。
uthash 是一个用 C 语言编写的开源库，使用宏实现了哈希表的增删改查等功能。
注意：使用哈希表时，要分别记录数组中每个元素出现的次数。
时间复杂度：O(N)。
空间复杂度：O(N)。

②排序

先使用快排函数排序两个数组，再通过双指针查找交集。
时间复杂度：O(Nlogn)。
空间复杂度：O(1)。

代码详解

uthash

int* intersect(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize) {    
    struct hash {
        int value;
        int count;
        // makes this structure hashable.
        UT_hash_handle hh; 
    };
    
    struct hash *hashTable = NULL;
    int* result = malloc(sizeof(int)*nums1Size);
    
    for (int i = 0; i < nums1Size; i++) {
        struct hash *h;
        // 查找值。
        HASH_FIND_INT(hashTable, nums1+i, h);
        
        if (!h) {
            h = malloc(sizeof(struct hash));
            h->value = nums1[i];
            h->count = 1;
            // 若值不存在则添加，并令出现次数==1。
            HASH_ADD_INT(hashTable, value, h);
        }
        // 若值已存在则出现次数+1。
        else
            h->count++;
    }
    for (int i = 0; i < nums2Size; i++) {
        struct hash *h;
        HASH_FIND_INT(hashTable, nums2+i, h);
        
        if (h && h->count > 0) {
            result[(*returnSize)++] = h->value;
            h->count--;
        }
    }
    
    return result;
}

排序 + 双指针查找

// 快排函数(升序)。
int compare(const void* a, const void* b) {
	/*
	 bug: 若是将 > 改为 -,可能溢出整型范围。
	如测试数据: [-2147483648,1],在排序时会导致异常: runtime error: signed integer overflow: -2147483648 - 1 cannot be represented in type 'int' (solution.c)
	 */
    return *(int*)a > *(int*)b; 
}

int* intersect(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize) {    
    // 排序。
    qsort(nums1, nums1Size, sizeof(int), compare);
    qsort(nums2, nums2Size, sizeof(int), compare);
    
    int pos1 = 0, pos2 = 0; 
    int* result = malloc(sizeof(int)*nums1Size);
    *returnSize = 0;
    
    // 双指针。
    while (pos1 < nums1Size && pos2 < nums2Size) {
        if (nums1[pos1] < nums2[pos2])
            pos1++;
        else if (nums1[pos1] > nums2[pos2])
            pos2++;
        else {
            result[(*returnSize)++] = nums1[pos1];
            pos1++;
            pos2++;
        }
    }
    
    return result;
}