力扣 350. 两个数组的交集 II C语言实现

题目描述：

给你两个整数数组 nums1 和 nums2 ，请你以数组形式返回两数组的交集。返回结果中每个元素出现的次数，应与元素在两个数组中都出现的次数一致（如果出现次数不一致，则考虑取较小值）。可以不考虑输出结果的顺序。

题目链接

方法1. 使用哈希表

 遍历其中一个数组，将其存入哈希表中，并设置元素次数，初始设为1。每次存储时查找哈希表有无该元素，如果有，则对已经存在的元素键值加1.

然后遍历第二个数组，查找哈希表中是否存在该元素，如果有首先判断键值是多少，如果大于0，则插入新创建的数组中，并对哈希表中该元素的键值减1；如果等于0则表明该元素已经被遍历过插入到了新创建的数组中了，不再进行操作。

在写该段代码时遇到的小插曲：一开始提交的时候显示一个示例结果错误无法通过，但经过检查没有发现错误，且执行代码的时候该示例并未出错。最后发现是哈希表没有初始化为空。

力扣的判题机在读取代码后，对每个测试用例，都会初始化一次类，但全局变量和类内静态变量需要自己手动初始化。

typedef struct hashTable
 {
    int key;
    int value;
    UT_hash_handle hh;
 }Hash;
 Hash* all;
 Hash* find(int ikey)
 {
    Hash* f;
    HASH_FIND_INT(all, &ikey, f);
    return f;
 }
 void insert(int ikey, int ivalue)
 {
    Hash* is;
    is = (Hash*)malloc(sizeof(Hash));
    is->key = ikey;
    is->value = ivalue;
    HASH_ADD_INT(all, key, is);
 }
int* intersect(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize){
    all = NULL; //此处如果不置为空则无法提交成功
    //int minsize = nums1Size>nums2Size?nums2Size:nums1Size;
    int flag=0;
    int *newnums;
    //newnums = (int*)malloc(sizeof(int)*minsize);
    newnums = (int*)malloc(sizeof(int));
    for(int i=0; i<nums1Size; ++i)
    {
        Hash* cur;
        cur = find(nums1[i]);
        if(cur==NULL)
        {
            insert(nums1[i], 1);
        }
        else
        {
            cur->value++;
        }
    }
    for(int j=0; j<nums2Size; ++j)
    {
        Hash* cur2;
        cur2 = find(nums2[j]);
        if(cur2!=NULL)
        {
            if(flag!=0)
            {
                newnums = (int*)realloc(newnums, sizeof(int)*(flag+1));
            }
            if(cur2->value>0)
            {
                newnums[flag++] = cur2->key;
                cur2->value--;
            }
            
        }
    }
    *returnSize = flag;
    return newnums;
}

方法2：先排序再查找

分别对两个数组快排，再设置两个变量查找。

qsort参数的简单解释在这一篇

int cmp(const void* a, const void* b)
 {
     return *(int*)a - *(int*)b;
 }
int* intersect(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize){
    qsort(nums1, nums1Size, sizeof(int), cmp);
    qsort(nums2, nums2Size, sizeof(int), cmp);
    int flag1 = 0;
    int flag2 = 0;
    int temp = 0;
    int minsize = nums1Size>nums2Size?nums2Size:nums1Size;
    int* newnums = (int*)malloc(sizeof(int)*minsize);
    while(flag1<nums1Size && flag2<nums2Size)
    {
        if(nums1[flag1]<nums2[flag2])
        {
            flag1++;
        }
        else if(nums1[flag1]>nums2[flag2])
        {
            flag2++;
        }
        else
        {
            newnums[temp++] = nums1[flag1];
            flag1++;
            flag2++;
        }
    }
    *returnSize = temp;
    return newnums;
}

方法2比较简单，可以继续熟悉qsort函数的使用。