【2.22】算法5：哈希表、排序、双指针

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

方法一：排序+双指针

如果两个数组是有序的，则可以使用双指针的方法得到两个数组的交集。

首先对两个数组进行排序，然后使用两个指针遍历两个数组。

初始时，两个指针分别指向两个数组的头部。每次比较两个指针指向的两个数组中的数字，如果两个数字不相等，则将指向较小数字的指针右移一位，如果两个数字相等，将该数字添加到答案，并将两个指针都右移一位。当至少有一个指针超出数组范围时，遍历结束。

int cmp(const void* _a, const void* _b) {
    int *a = _a, *b = (int*)_b;
    return *a == *b ? 0 : *a > *b ? 1 : -1;
}

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;//初试化为0
    int* intersection = (int*)malloc(sizeof(int) * fmin(nums1Size, nums2Size));
    int index1 = 0, index2 = 0;
    while (index1 < nums1Size && index2 < nums2Size) {
        if (nums1[index1] < nums2[index2]) {//不相等，较小的数往后循环
            index1++;
        } else if (nums1[index1] > nums2[index2]) {
            index2++;
        } else {
            intersection[(*returnSize)++] = nums1[index1]; //相等，添加到结果数组中
            index1++;
            index2++;
        }
    }
    return intersection;
}

方法二：哈希表

由于同一个数字在两个数组中都可能出现多次，因此需要用哈希表存储每个数字出现的次数。对于一个数字，其在交集中出现的次数等于该数字在两个数组中出现次数的最小值。

首先遍历第一个数组，并在哈希表中记录第一个数组中的每个数字以及对应出现的次数，然后遍历第二个数组，对于第二个数组中的每个数字，如果在哈希表中存在这个数字，则将该数字添加到答案，并减少哈希表中该数字出现的次数。

为了降低空间复杂度，首先遍历较短的数组并在哈希表中记录每个数字以及对应出现的次数，然后遍历较长的数组得到交集

C++版：

class Solution {
    public int[] intersect(int[] nums1, int[] nums2) {
        // 挑选出两个数组找个短的那个
        if (nums1.length > nums2.length) {
            return intersect(nums2, nums1);
        }

        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        // nums1 = [4,9,5], nums2 = [9,4,9,8,4]
        for (int num : nums1) {
            // map.getOrDefault : 存在这个数就返回，不存在就返回默认值
            int count = map.getOrDefault(num, 0) + 1;
            map.put(num, count);
        }
        // 开辟一块内存空间用来存放两个数组的交集
        int[] intersection = new int[nums1.length];
        int index = 0;
        for (int num : nums2) {
            // num1中不存在这个数就在map中添加num=0
            int count = map.getOrDefault(num, 0);
            // 存在这个数就往后执行
            if (count > 0) {
                // 把这个数填充到数组中
                intersection[index++] = num;
                // 计数减一
                count--;
                // 如果还大于0
                if (count > 0) {
                    // 再次添加进去，覆盖之前那个key
                    map.put(num, count);
                } else {
                    // 不大于0移除这个数
                    map.remove(num);
                }
            }
        }
        // public static int[] copyOfRange(int[] original, int from, int to)
        // 对已有([9, 4, 0])的数组进行截取和赋值,结果为[9,4]
        return Arrays.copyOfRange(intersection, 0, index);
    }
}

C语言版：

 
 
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */         //注意此处返回数组必须是动态分配的才行
 
int* intersect(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize){
    typedef struct {
     int key;                 //C语言对哈希表的配置 定义一个包含键值和出现次数value的结构体
     int value;
     UT_hash_handle hh;
     } Hash;

 Hash *hash = NULL;        //声明一个指向该结构体的指针hash
 Hash * find(int key){        //在哈希表中查找是否存在给定key值，若存在返回指向其地址的指针
     Hash *tep = NULL;        //否则返回空指针
     HASH_FIND_INT(hash,&key,tep);
     return tep;
 }

 void insert(int key){        //将较小数组key值和其出现次数插入哈希表
     Hash * tep = find(key);
     if(tep==NULL){            //若找不到，则插入
         Hash *s = (Hash*)malloc(sizeof(Hash)); //动态分配一个结构体
         s->key=key;                             //给其赋值
         s->value=1;
         HASH_ADD_INT(hash,key,s);  //调用库函数，将s所指的Hash结构体插入到hash老巢中key映射的地址上
     }else{
         tep->value++; //若已存在，则出现次数++
     }
 }
    if(nums1Size<nums2Size){  
        int *ret = (int*)malloc(sizeof(int)*(nums1Size));
        *returnSize=0;
        for(int i=0;i<nums1Size;i++){        //将较小数组插入哈希表
            insert(nums1[i]);
        }
        for(int j=0;j<nums2Size;j++){        //依次查找较大数组各元素是否在哈希表中
            Hash *it = find(nums2[j]);
            if(it==NULL){}     //若不存在则为空，且此处必须加这一行，否则下一行it为空会报错
            else if(it->key==nums2[j]&&it->value!=0){ //当存在且哈希表中此key出现次数>0
                it->value--;        //出现次数--
                ret[(*returnSize)++]=nums2[j];    //将交集依次放入新建数组ret
            }        //注意此处*returnSize初始化为0，这样写可以省一个int index变量
        }
        return ret;    //返回该数组
    }else{
        int *ret = (int*)malloc(sizeof(int)*(nums2Size));
        *returnSize=0;
        for(int i=0;i<nums2Size;i++){
            insert(nums2[i]);
        }
        for(int j=0;j<nums1Size;j++){
            Hash *it = find(nums1[j]);
            if(it==NULL){}
            else if(it->key==nums1[j]&&it->value!=0){
                it->value--;
                ret[(*returnSize)++]=nums1[j];
            }
        }
        return ret;
    }
    
}