LeetCode 350.两个数组的交集 II

题目：

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

示例 1：

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

示例 2:

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

提示：

• 1 <= nums1.length, nums2.length <= 1000
• 0 <= nums1[i], nums2[i] <= 1000

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/intersection-of-two-arrays-ii

题解：

方法一：哈希表
官方题解里没有c语言的做法，以下是参考了评论区的做法。（自己太菜了做不出来呜呜…）
先遍历第一个数组，将第一个数组中出现的数字及出现次数存到哈希表中，然后遍历第二个数组，如果有数字能在哈希表中找到，就把这个数字存到结果数组中，并且减少该数字在哈希表中出现的次数。
先遍历较短的数组并在哈希表中记录，这样可以降低空间复杂度。

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */

struct hashTable
{
    int key;
    int val;
    UT_hash_handle hh;
};
struct hashTable* set;
int count(int* nums1,int nums1Size,int* nums2,int nums2Size,int* result)
{
    int count=0;
    for(int i=0;i<nums1Size;i++)
    {
        struct hashTable* tmp;
        HASH_FIND_INT(set,nums1+i,tmp);
        if(tmp==NULL)
        {
            tmp=malloc(sizeof(struct hashTable));
            tmp->key=nums1[i];
            tmp->val=1;
            HASH_ADD_INT(set,key,tmp);
        }
        else
        {
            tmp->val++;
        }
    }
    for(int i=0;i<nums2Size;i++)
    {
        struct hashTable* tmp;
        HASH_FIND_INT(set,nums2+i,tmp);
        if(tmp!=NULL&&tmp->val>0)
        {
            result[count]=tmp->key;
            tmp->val--;
            count++;
        }
    }
    return count;
}
int* intersect(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize){
    set=NULL;
    int* result=NULL;
    if(nums1Size>nums2Size)
    {
        result=malloc(sizeof(int)*nums2Size);
        *returnSize=count(nums1,nums1Size,nums2,nums2Size,result);
    }
    else
    {
        result=malloc(sizeof(int)*nums1Size);
        *returnSize=count(nums1,nums1Size,nums2,nums2Size,result);
    }
    return result;
}

方法二：先排序后遍历
先对两个数组按照从小到大的顺序进行排序，然后用两个指针分别指向两个数组的头部。如果两个元素相等，就将该元素添加到结果数组中并将两个指针都右移一位；如果不相等，就将较小元素的指针右移一位，直到遍历结束。

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */

int cmp(const void* _a,const void* _b)
{
    int* a=(int*)_a;
    int* b=(int*)_b;
    return *a-*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);
    *returnSize=0;
    int* result=(int*)malloc(sizeof(int)*fmin(nums1Size,nums2Size));
    int p1=0,p2=0;
    while(p1<nums1Size&&p2<nums2Size)
    {
        if(nums1[p1]<nums2[p2])
        {
            p1++;
        }
        else if(nums1[p1]>nums2[p2])
        {
            p2++;
        }
        else
        {
            result[(*returnSize)]=nums1[p1];
            (*returnSize)++;
            p1++;
            p2++;
        }
    }
    return result;
}