leetcode 349 两个数组的交集

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

 

示例 1：

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

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

说明：

输出结果中的每个元素一定是唯一的。
我们可以不考虑输出结果的顺序.

自己思路直接暴力，两个for循环搞定，但是这有个条件，输出结果每个元素是唯一的，可以在两个for循环之后再去重，我的想法是，两个for循环之前就去重，这样时间复杂度就o(size1*size2),size1是去重之后的剩余个数

代码：

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int cmp(const void* a,const void *b){
    return  *(int*)a-*(int*)b;
}
int* intersection(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize){
    int len=nums1Size>nums2Size?nums1Size:nums2Size;
    if(nums1Size<=0 || nums2Size<=0){
        *returnSize=0;
        return (int*)malloc(sizeof(int));
    }
    int flag=0;
    qsort(nums1,nums1Size,sizeof(nums1[0]),cmp);
    int *temp=(int*)malloc(len*sizeof(int));
    int temp_num=0;
    temp[0]=nums1[0];
    temp_num++;
    for(int i=1;i<nums1Size;i++){
        if(nums1[i]==temp[temp_num-1]){
            continue;
        }
        temp[temp_num]=nums1[i];
        temp_num++;
    }
    int *res=(int*)malloc(len*sizeof(int));
    for(int i=0;i<temp_num;i++){
        for(int j=0;j<nums2Size;j++){
            if(temp[i]==nums2[j]){
                res[flag]=temp[i];
                flag++;
                break;
            }
        }
    }
    *returnSize=flag;

    return res;
}

还有就是直接用哈希表：key是数值，flag是标记，在1出现，就是1，在nums1出现又在nums2出现就是2.只有2才是交集。

遍历哈希表，时间复杂度O（max（n））， 应该是吧...时间复杂度不太确定。

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
typedef struct hashT{
    int val;
    int flag;
    UT_hash_handle hh;
}HashT;
HashT *hashTable;

void iniNum1(const int *nums,int nums1Size){
    for(int i=0;i<nums1Size;i++){
        
        addHashT_1(nums[i]);
    }
}
void iniNum2(const int *nums,int nums1Size){
    for(int i=0;i<nums1Size;i++){
        addHashT_2(nums[i]);
    }
}
void addHashT_1(int val){
    HashT *res;
    HASH_FIND_INT(hashTable,&val,res);
    if(res==NULL){
        res=(HashT*)malloc(sizeof(HashT));
        res->val=val;
        res->flag=1;
        HASH_ADD_INT(hashTable,val,res);
    }else{
        return;
    }
}
void addHashT_2(int val){
    HashT *res;
    HASH_FIND_INT(hashTable,&val,res);
    if(res!=NULL){
        if(res->flag==1){
            res->flag++;
        }
    }else{
        return;
    }
}
void freeHash(){
    free(hashTable);
    hashTable=NULL;
}
int* intersection(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize){
    iniNum1(nums1,nums1Size);
    iniNum2(nums2,nums2Size);
    int *res=(int*)malloc((nums1Size>nums2Size?nums1Size:nums2Size)*sizeof(int));
    *returnSize=0;
    int tt=0;
    HashT  *iter;
    for(iter=hashTable;iter!=NULL;iter=iter->hh.next){
        if(iter->flag==2){
            res[*returnSize]=iter->val;
            (*returnSize)++;
        }
    }
    
    // for(int i=0;i<*returnSize;i++){
    //     printf("%d\n",res[i]);
    // }
    freeHash();
    return res;
}

WA了一次，因为哈希表忘记释放内存。。以后一定不能忘了。